2.11学习总结

Java能学吗2025-02-12 9:35
#include<stdio.h>
int main()
{	
	int n, m;
	scanf("%d %d", &n, &m);
	int a[15005], b[15005];
	for (int i = 0; i < n; i++)
		scanf("%d", &a[i]);
	int ans = a[n - 1] - a[0] + 1;
	for (int i = 0; i < n - 1; i++)
		b[i] = a[i + 1] - a[i];
	for(int i=0;i<n-2;i++)
		for(int j=0;j<n-2-i;j++)
			if (b[j + 1] > b[j])
			{
				int temp = b[j + 1];
				b[j + 1] = b[j];
				b[j] = temp;
			}
	for (int i = 0; i < m - 1; i++)
		ans =ans - (b[i] - 1);
	printf("%d", ans);
	return 0;
}

#include<stdio.h>

int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	int a[n + 5];
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);
	}
	int x[m + 5], y[m + 5], res = -1;
	for (int i = 0; i < m; i++)
	{
		scanf("%d %d", &x[i], &y[i]);
		if (res < x[i])
		{
			res = x[i];
		}
	}
	int ans = 1e9;
	for (int i = res; i <= n; i++)
	{
		if (ans > a[i])
			ans = a[i];
	}
	printf("%d", ans);
	return 0;
}

c

#include <stdio.h>
#include <stdlib.h>

#define MAXN 5005
#define MAXM 200005

// 定义边的结构体
typedef struct {
    int start;  // 边的起点
    int end;    // 边的终点
    int value;  // 边的权值
} Edge;

Edge edges[MAXM];  // 存储所有的边
int parent[MAXN];  // 并查集的父节点数组
int n, m;          // n 为顶点数，m 为边数
int edgeCount = 0; // 记录已经加入最小生成树的边的数量
int totalWeight = 0; // 最小生成树的总权值

// 比较函数，用于 qsort 对边按权值排序
int compare(const void *a, const void *b) {
    Edge *edgeA = (Edge *)a;
    Edge *edgeB = (Edge *)b;
    return edgeA->value - edgeB->value;
}

// 查找元素 x 所属集合的根节点，并进行路径压缩
int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

// 合并两个集合
void unionSets(int x, int y) {
    int rootX = find(x);
    int rootY = find(y);
    if (rootX != rootY) {
        parent[rootX] = rootY;
    }
}

// Kruskal 算法核心函数
void kruskal() {
    // 对边按权值从小到大排序
    qsort(edges, m, sizeof(Edge), compare);

    for (int i = 0; i < m; i++) {
        int start = edges[i].start;
        int end = edges[i].end;
        int value = edges[i].value;

        int rootStart = find(start);
        int rootEnd = find(end);

        // 如果加入这条边不会形成环
        if (rootStart != rootEnd) {
            unionSets(start, end);
            edgeCount++;
            totalWeight += value;

            // 当加入的边数达到 n - 1 条时，最小生成树构建完成
            if (edgeCount == n - 1) {
                break;
            }
        }
    }
}

int main() {
    // 读取顶点数和边数
    scanf("%d %d", &n, &m);

    // 初始化并查集，每个顶点的父节点是自身
    for (int i = 1; i <= n; i++) {
        parent[i] = i;
    }

    // 读取每条边的信息
    for (int i = 0; i < m; i++) {
        scanf("%d %d %d", &edges[i].start, &edges[i].end, &edges[i].value);
    }

    // 执行 Kruskal 算法
    kruskal();

    // 判断图是否连通
    if (edgeCount == n - 1) {
        printf("%d\n", totalWeight);
    } else {
        printf("orz\n");
    }

    return 0;
}

c++

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n, m, i, j, u, v, total;
struct node {
	int start, to;
	long long edge;
}bian[10000000];
int f[1000000];
long long ans;
bool cmp(node a, node b) {
	return a.edge < b.edge;
}
int find(int x) {
	if (f[x] == x)return x;
	else return f[x] = find(f[x]);
}
void tree() {
	for (int i = 1; i <= m; i++) {
		int u = find(bian[i].start);
		int v = find(bian[i].to);
		if (u == v)continue;
		ans += bian[i].edge;
		f[u] = v;
		total++;
		if (total == n - 1)break;
	}
}

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)f[i] = i;
	for (int i = 1; i <= m; i++) {
		cin >> bian[i].start >> bian[i].to >> bian[i].edge;
	}
	sort(bian + 1, bian + m + 1, cmp);
	tree();
	if (total == n - 1)
		cout << ans;
	else cout << "orz";
	return 0;
}

#include <stdio.h>
#include <stdlib.h>

#define MAXN 1005

// 定义方向数组，用于表示上下左右四个方向
int dx[4] = { -1, 1, 0, 0 };
int dy[4] = { 0, 0, -1, 1 };

// 定义队列结构
typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point items[MAXN * MAXN];
    int front;
    int rear;
} Queue;

// 初始化队列
void initQueue(Queue* q) {
    q->front = 0;
    q->rear = 0;
}

// 判断队列是否为空
int isEmpty(Queue* q) {
    return q->front == q->rear;
}

// 入队操作
void enqueue(Queue* q, Point p) {
    q->items[q->rear++] = p;
}

// 出队操作
Point dequeue(Queue* q) {
    return q->items[q->front++];
}

// 检查坐标 (x, y) 是否在迷宫范围内且与当前格子值不同
int isValid(int x, int y, int n, char maze[MAXN][MAXN], char target) 
{
    return x >= 0 && x < n && y >= 0 && y < n && maze[x][y] != target;
}

// BFS 函数，从 (x, y) 开始进行广度优先搜索
int bfs(int x, int y, int n, char maze[MAXN][MAXN], int visited[MAXN][MAXN], int areaId) {
    Queue q;
    initQueue(&q);
    Point start = { x, y };
    enqueue(&q, start);
    visited[x][y] = areaId;
    int size = 0;

    while (!isEmpty(&q)) {
        Point cur = dequeue(&q);
        size++;
        char target = maze[cur.x][cur.y];

        for (int i = 0; i < 4; i++) {
            int newX = cur.x + dx[i];
            int newY = cur.y + dy[i];
            if (isValid(newX, newY, n, maze, target) && visited[newX][newY] == 0) {
                Point next = { newX, newY };
                enqueue(&q, next);
                visited[newX][newY] = areaId;
            }
        }
    }
    return size;
}

int main() {
    int n, m;
    char maze[MAXN][MAXN];
    int visited[MAXN][MAXN] = { 0 };
    int areaSize[MAXN * MAXN] = { 0 };

    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%s", maze[i]);
    }

    int areaId = 1;
    for (int i = 0; i < m; i++) {
        int x, y;
        scanf("%d %d", &x, &y);
        x--;  // 转换为 0 索引
        y--;

        if (visited[x][y] == 0) {
            areaSize[areaId] = bfs(x, y, n, maze, visited, areaId);
            areaId++;
        }
        printf("%d\n", areaSize[visited[x][y]]);
    }

    return 0;
}

#include <stdio.h>

#define INF 1e9

int n, f[205], m[205][205];

int min(int a, int b) {
    return a < b ? a : b;
}

int main() 
{
    // 读取出租站的数量
    scanf("%d", &n);

    // 读取租金矩阵
    for (int i = 1; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            scanf("%d", &m[i][j]);
        }
    }

    // 初始化 f 数组
    for (int i = 1; i <= n; i++) {
        f[i] = INF;
    }
    f[1] = 0;  // 从出租站 1 到出租站 1 的租金为 0

    // 动态规划计算最少租金
    for (int i = 1; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            f[j] = min(f[j], f[i] + m[i][j]);
        }
    }

    // 输出从出租站 1 到出租站 n 的最少租金
    printf("%d", f[n]);

    return 0;
}
相关推荐
闻缺陷则喜何志丹5 天前
【测试用例翔实 栈】P8815 [CSP-J 2022] 逻辑表达式
c++·算法·栈·洛谷·短路·与·或
羑悻的小杀马特1 个月前
【深度优先搜索篇】走迷宫的魔法：算法如何破解迷宫的神秘密码
c++·算法·深度优先遍历·洛谷·走迷宫
羑悻的小杀马特1 个月前
【动态规划篇】穿越算法迷雾：约瑟夫环问题的奇幻密码
c++·算法·蓝桥杯·动态规划·洛谷·约瑟夫环
qwq_ovo_pwp3 个月前
题解 洛谷 Luogu P2440 木材加工 二分答案 C/C++
c语言·c++·算法·二分答案·洛谷
XuYueming3 个月前
[NOIP2022] 比赛 随机排列 部分分
数学·线段树·题解·单调栈·洛谷·扫描线·二维数点·部分分·概率 & 期望
qwq_ovo_pwp3 个月前
题解 洛谷 Luogu P1308 [NOIP2011 普及组] 统计单词数 C++
c++·洛谷
xzz_06114 个月前
洛谷 AT_abc275_c [ABC275C] Counting Squares 题解
c++·题解·洛谷·atcoder·暴力算法
mengsi554 个月前
最大正方形 Python题解
开发语言·python·leetcode·前缀和·动态规划·洛谷·acwing
xzz_06114 个月前
洛谷 AT_abc365_c [ABC365C] Transportation Expenses 题解
c++·二分查找·题解·洛谷·atcoder
热门推荐
01如何在WPS和Word/Excel中直接使用DeepSeek功能02DeepSeek本地部署详细指南03DeepSeek各版本说明与优缺点分析04本地部署DeepSeek教程（Mac版本）05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06DeepSeek r1本地安装全指南07保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型08在Windows下安装Ollama并体验DeepSeek r1大模型09将DeepSeek接入Word，打造AI办公助手10DeepSeek RAGFlow构建本地知识库系统