「THUWC 2017」大葱的神力 - 题解

原创 于 2024-03-15 16:51:08 发布 · 1.2k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

博客围绕算法题解展开，针对不同测试点给出解法，如模拟退火、费用流等。还介绍将程序挂载到GPU上运行，包括GPU相关知识、挂载步骤、性能测试、程序改编，以及解决编译器报错的方案，最后说明判断运行结果是否正确的方法。
部署运行你感兴趣的模型镜像
忠告：如果你想抄题解的，可以离开，这不是一时半会儿能解决的问题

前置知识：

  1. 学习笔记：费用流icon-default.png?t=N7T8https://blog.youkuaiyun.com/weixin_44043668/article/details/108738212
  2. C++动态规划详解icon-default.png?t=N7T8https://blog.youkuaiyun.com/weixin_51951103/article/details/120241450
  3. C++ 背包问题icon-default.png?t=N7T8https://blog.youkuaiyun.com/weixin_43899008/article/details/124738946
  4. 模拟退火算法（c++实现）（VIP文章）icon-default.png?t=N7T8https://blog.youkuaiyun.com/qq547276542/article/details/77800776
  5. TSP--模拟退火算法（c++实现+详细解释）icon-default.png?t=N7T8https://blog.youkuaiyun.com/qq_40738840/article/details/84324494

测试点1：

观察数据点 n = m = 5。

1 号，2 号，3 号，5 号物品都可以达到自己的最优选择。而枚举 4 号的物品的摆放会发现只有 4 号物品放入第 1 个背包时才能达到最优解。
最后玩出来的结果是：

3
3
2
1
1

测试点2、8、9、10：

测试点2：

观察数据 n=25,m=8。
理论上可以用搜索 + 剪枝，但是因为我实在太懒了，所以直接写了一个模拟退火。
跑了大概 3 分钟跑出来了最优解 108。

测试点8、9、10：

观察数据，无规律。

直接写随机化算法吧，模拟退火就是个不错的选择，代码细节我们等会儿来说。

据说这个退火算法坚持跑1\sim 2年可以跑出结果。。。

代码：
#include <cmath>
#include <ctime>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
using namespace std;

const int MAXN = 1000; // 定义最大商品数
const int MAXM = 300;  // 定义最大抽屉数
const int INF = (1 << 30); // 定义一个非常大的数，作为无穷大的标记

int V1[MAXN + 5], V2[MAXN + 5], val[MAXN + 5][MAXM + 5]; // 商品价值，抽屉大小和商品在抽屉中的价值
int ans[MAXN + 5], tmp[MAXN + 5], nw[MAXN + 5], res = 0, N, M; // 当前结果，临时数组，当前方案，最优解的价值，商品数和抽屉数

// 获取当前方案的总价值
int get_ans() {
	int ret = 0, j = 1, re = V2[1];
	for (int i = 1; i <= N; i++) {
		if (j > M)
			tmp[nw[i]] = 0;
		else if (re >= V1[nw[i]]) {
			tmp[nw[i]] = j, re -= V1[nw[i]];
			ret += val[nw[i]][j];
		} else
			j++, i--, re = V2[j];
	}
	return ret;
}

int real_ans[MAXN + 5], real_res = 0; // 最优方案和最优价值

int main() {
	srand(time(NULL)); // 使用当前时间来初始化随机数生成器

	freopen("drawer8.in", "r", stdin); // 从文件读取输入

	scanf("%d%d", &N, &M); // 读取商品数和抽屉数
	for (int i = 1; i <= N; i++)
		scanf("%d", &V1[i]); // 读取每个商品的价值
	for (int i = 1; i <= M; i++)
		scanf("%d", &V2[i]); // 读取每个抽屉的大小
	for (int i = 1; i <= N; i++)
		for (int j = 1; j <= M; j++)
			scanf("%d", &val[i][j]); // 读取商品在抽屉里的价值

	// 使用模拟退火算法来求解
	while (true) {
		for (int i = 1; i <= N; i++)
			nw[i] = i;
		random_shuffle(nw + 1, nw + N + 1); // 随机生成一种方案
		res = get_ans(); // 计算当前方案的价值

		for (double T = 1E12; T >= 1E-5; T *= 0.986) { // 模拟退火过程
			int x = rand() % N + 1, y = rand() % N + 1;
			swap(nw[x], nw[y]); // 随机交换两个商品
			if (get_ans() > res || 1.0 / (1 + exp((res - get_ans()) / T)) >= 1.0 / rand()) {
				for (int j = 1; j <= N; j++)
					ans[j] = tmp[j]; // 更新当前最优解
				res = get_ans(); // 获取新的价值
			} else
				swap(nw[x], nw[y]); // 恢复之前的方案
		}

		// 更新历史最优解
		if (res > real_res) {
			real_res = res;
			for (int i = 1; i <= N; i++)
				real_ans[i] = ans[i]; // 记录新的最优方案
			FILE *f = fopen("drawer8.out", "w"); // 打开文件用于写入结果
			for (int i = 1; i <= N; i++)
				fprintf(f, "%d\n", real_ans[i]); // 将最优方案写入文件
			printf("%d\n", real_res); // 在控制台输出最优解的价值
		}
	}
}

测试点3：

观察数据 m=1
很经典的 01 背包，直接写 dp 就可以过了。

代码：
#include <cstdio>
#include <algorithm>
using namespace std;

// 定义最大物品数量和最大价值
const int MAXN = 2000;
const int MAXV = 10000;

// dp[i][j] 表示考虑前i件物品，总体积不超过j的情况下，可以获得的最大价值
int dp[MAXN + 5][MAXV + 5];
// V[i] 表示第i件物品的体积
int V[MAXN + 5];
// pre[i][j] 表示获取dp[i][j]的最大价值时，是否选择了第i件物品
bool pre[MAXN + 5][MAXV + 5];
// tag[i] 表示最终解中是否选择了第i件物品
bool tag[MAXN + 5];

// 递归函数，用于找出选择的物品
void get_ans(int i, int j) {
    if (i == 0) return; // 如果已经考虑完所有物品，则返回
    if (pre[i][j]) { // 如果选择了第i件物品
        tag[i] = true; // 标记为选择
        get_ans(i - 1, j - V[i]); // 继续考虑前一个物品，容量减少V[i]
    } else {
        get_ans(i - 1, j); // 如果没有选择第i件物品，直接考虑前一个物品
    }
}

int main() {
    int N, M, K;
    scanf("%d%d", &N, &M); // 读入物品数量N和背包容量M（这里的M未使用）
    for (int i = 1; i <= N; i++)
        scanf("%d", &V[i]); // 读入每个物品的体积
    scanf("%d", &K); // 读入背包的容量限制
    for (int i = 1; i <= N; i++) {
        int k;
        scanf("%d", &k); // 读入每个物品的价值
        for (int j = K; j >= V[i]; j--) {
            // 更新dp数组
            if (dp[i - 1][j - V[i]] + k > dp[i - 1][j]) {
                dp[i][j] = dp[i - 1][j - V[i]] + k; // 更新最大价值
                pre[i][j] = true; // 记录选择了这个物品
            } else {
                dp[i][j] = dp[i - 1][j]; // 不选择这个物品
                pre[i][j] = false;
            }
        }
    }
    get_ans(N, K); // 回溯找出选择的物品
    for (int i = 1; i <= N; i++)
        puts(tag[i] ? "1" : "0"); // 输出每个物品是否被选择
    // printf("%d\n", dp[N][K]); // 可以输出最大价值
}

测试点4、5、6：

测试点4：

观察数据，所有物品的体积都是 233。

这个时候就可以确定每个背包能装的物品数量是多少，背包容量和物体体积转换为了物品数量限制。

这个时候就是一个最大权匹配，写个费用流就可以了。

测试点5：

观察数据，所有物品的体积都是 2233。

跟 测试点4 一样的解法，只是时间跑得久一些，大概 5 秒。

测试点6：

观察数据，所有物品的体积都是 19260817 在 19660600 \sim 19660720 这个范围以内。

体积不一样，好像并不能再使用费用流了？

但实际上物品之间的体积都是微小扰动造成的，也就是说物品之间的体积差相对于物品体积本身而言非常微小，以至于可以忽略不计。

所以我们直接把物品体积当作所有物品体积的最大值来算就可以了。

代码：
#include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;

// 节点和边的最大数目
const int MAXN = 1000;
const int MAXM = 700;
const int MAXV = MAXN + MAXM;
const int INF = (1 << 30);

struct edge {
	int to, flow, cap, dis;
	edge *nxt, *rev;
} edges[4 * MAXN * MAXM + 5], *adj[MAXV + 5], *cur[MAXV + 5], *ecnt;

// 定义一个流图数据结构
struct flow_graph {
	int S, T, cost, dist[MAXV + 5]; // S源点，T汇点，cost总费用，dist到各点最短费用
	bool vis[MAXV + 5], inq[MAXV + 5]; // vis检查是否访问过，inq检查是否在队列中
	deque<int>que; // 双端队列，用于执行SPFA算法

	// 初始化
	void init() {
		ecnt = &edges[0];
	}

	// 添加边
	void addedge(int u, int v, int c, int w) {
		edge *p = (++ecnt), *q = (++ecnt);
		p->to = v, p->cap = c, p->dis = w, p->flow = 0;
		p->nxt = adj[u], adj[u] = p;
		q->to = u, q->cap = 0, q->dis = -w, q->flow = 0;
		q->nxt = adj[v], adj[v] = q;
		p->rev = q, q->rev = p;
	}

	// 执行SPFA算法，寻找最短费用的增广路径
	bool relabel() {
		for (int i = S; i <= T; i++)
			dist[i] = INF, cur[i] = adj[i];
		que.push_back(S);
		dist[S] = 0;
		inq[S] = true;
		while ( !que.empty() ) {
			int f = que.front();
			que.pop_front();
			inq[f] = false;
			for (edge *p = adj[f]; p != NULL; p = p->nxt) {
				if ( p->cap > p->flow ) {
					if ( dist[p->to] > dist[f] + p->dis ) {
						dist[p->to] = dist[f] + p->dis;
						if ( !inq[p->to] ) {
							inq[p->to] = true;
							if ( !que.empty() && dist[p->to] < dist[que.front()] )
								que.push_front(p->to);
							else que.push_back(p->to);
						}
					}
				}
			}
		}
		return !(dist[T] == INF);
	}

	// 增广路径
	// x当前节点，tot要增广的流量
	int aug(int x, int tot) {
		if ( x == T ) {
			cost += tot * dist[T]; // 更新总费用
			return tot;
		}
		int sum = 0;
		vis[x] = true;
		for (edge *&p = cur[x]; p != NULL; p = p->nxt) {
			if ( p->cap > p->flow && !vis[p->to] && dist[x] + p->dis == dist[p->to] ) {
				int del = aug(p->to, min(tot - sum, p->cap - p->flow));
				sum += del, p->flow += del, p->rev->flow -= del;
				if ( sum == tot ) break;
			}
		}
		vis[x] = false;
		return sum;
	}

	// 最小费用流算法
	int min_cost_max_flow() {
		int flow = 0;
		while ( relabel() )
			flow += aug(S, INF);
		return flow;
	}
} G;

int V1[MAXN + 5], V2[MAXN + 5];

// 主函数
int main() {
	int N, M, mx = 0;
	scanf("%d%d", &N, &M); // N节点数目，M边数目
	G.init();
	G.S = 0, G.T = N + M + 1; // 初始化图，设置源点和汇点
	for (int i = 1; i <= N; i++) {
		scanf("%d", &V1[i]); // 输入V1数组
		G.addedge(G.S, i, 1, 0); // 源点连接V1中的每个节点，边权为1，费用为0
		mx = max(mx, V1[i]);
	}
	for (int i = 1; i <= M; i++) {
		scanf("%d", &V2[i]); // 输入V2数组
		G.addedge(N + i, G.T, V2[i] / mx, 0); // V2中的每个节点连接汇点，边权为V2[i]/mx，费用为0
	}
	for (int i = 1; i <= N; i++)
		for (int j = 1; j <= M; j++) {
			int k;
			scanf("%d", &k); // 输入费用矩阵
			G.addedge(i, N + j, 1, -k); // 连接V1和V2，边权为1，费用为-k
		}
	G.min_cost_max_flow(); // 执行最小费用最大流算法
	for (int i = 1; i <= N; i++) {
		int ans = N;
		for (edge *p = adj[i]; p != NULL; p = p->nxt)
			if ( p->to != G.S && p->flow == 1 ) ans = p->to; // 配对结果
		printf("%d\n", ans - N); // 输出配对结果
	}
//  printf("%d\n", -G.cost); // 如果需要输出总费用，取消注释这一行
}

测试点7：

观察数据，除了物品 1 的体积为 46972 以外，其他物品的体积都为 11743。

我们直接枚举物品 1 的摆放位置，再跑费用流，取最优值。

时间复杂度有点高，跑了 1 分钟左右才跑出来最优解。

代码：（由于👆面有注释，所以这段不注释了~）
#include<queue>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN = 500;
const int MAXM = 100;
const int MAXV = MAXN + MAXM;
const int INF = (1<<30);
struct edge{
    int to, flow, cap, dis;
    edge *nxt, *rev;
}edges[4*MAXN*MAXM + 5], *adj[MAXV + 5], *cur[MAXV + 5], *ecnt;
struct flow_graph{
    int S, T, cost, dist[MAXV + 5];
    bool vis[MAXV + 5], inq[MAXV + 5];
    deque<int>que;
    void init() {
        ecnt = &edges[0];
        for(int i=S;i<=T;i++)
            adj[i] = NULL;
        cost = 0;
    }
    void addedge(int u, int v, int c, int w) {
        edge *p = (++ecnt), *q = (++ecnt);
        p->to = v, p->cap = c, p->dis = w, p->flow = 0;
        p->nxt = adj[u], adj[u] = p;
        q->to = u, q->cap = 0, q->dis = -w, q->flow = 0;
        q->nxt = adj[v], adj[v] = q;
        p->rev = q, q->rev = p;
    }
    bool relabel() {
        for(int i=S;i<=T;i++)
            dist[i] = INF, cur[i] = adj[i];
        que.push_back(S); dist[S] = 0; inq[S] = true;
        while( !que.empty() ) {
            int f = que.front(); que.pop_front(); inq[f] = false;
            for(edge *p=adj[f];p!=NULL;p=p->nxt) {
                if( p->cap > p->flow ) {
                    if( dist[p->to] > dist[f] + p->dis ) {
                        dist[p->to] = dist[f] + p->dis;
                        if( !inq[p->to] ) {
                            inq[p->to] = true;
                            if( !que.empty() && dist[p->to] < dist[que.front()] )
                                que.push_front(p->to);
                            else que.push_back(p->to);
                        }
                    }
                }
            }
        }
        return !(dist[T] == INF);
    }
    int aug(int x, int tot) {
        if( x == T ) {
            cost += tot*dist[T];
            return tot;
        }
        int sum = 0; vis[x] = true;
        for(edge *&p=cur[x];p!=NULL;p=p->nxt) {
            if( p->cap > p->flow && !vis[p->to] && dist[x] + p->dis == dist[p->to] ) {
                int del = aug(p->to, min(tot - sum, p->cap - p->flow));
                sum += del, p->flow += del, p->rev->flow -= del;
                if( sum == tot ) break;
            }
        }
        vis[x] = false;
        return sum;
    }
    int min_cost_max_flow() {
        int flow = 0;
        while( relabel() )
            flow += aug(S, INF);
        return flow;
    }
}G;
int V1[MAXN + 5], V2[MAXN + 5], val[MAXN + 5][MAXM + 5];
int ans[MAXN + 5], res = 0;
int main() {
    int N, M; scanf("%d%d", &N, &M);
    G.S = 0, G.T = N + M + 1; G.init();
    for(int i=1;i<=N;i++)
        scanf("%d", &V1[i]);
    for(int i=1;i<=M;i++)
        scanf("%d", &V2[i]);
    for(int i=1;i<=N;i++)
        for(int j=1;j<=M;j++)
            scanf("%d", &val[i][j]);
    for(int i=2;i<=N;i++)
        for(int j=1;j<=M;j++)
            G.addedge(i, N + j, 1, -val[i][j]);
    for(int i=2;i<=N;i++)
        G.addedge(G.S, i, 1, 0);
    for(int i=1;i<=M;i++)
        G.addedge(N + i, G.T, V2[i]/V1[2], 0);
    G.min_cost_max_flow(); res = -G.cost;
    for(int i=2;i<=N;i++) {
        int flag = N;
        for(edge *p=adj[i];p!=NULL;p=p->nxt)
            if( p->to != G.S && p->flow == 1 ) flag = p->to;
        ans[i] = flag - N;
    }
    for(int i=1;i<=M;i++) {
        if( V2[i] < V1[1] ) continue;
        G.init();
        for(int j=2;j<=N;j++)
            for(int k=1;k<=M;k++)
                G.addedge(j, N + k, 1, -val[j][k]);
        for(int j=2;j<=N;j++)
            G.addedge(G.S, j, 1, 0);
        for(int j=1;j<=M;j++)
            if( j == i ) G.addedge(N + j, G.T, (V2[j] - V1[1])/V1[2], 0);
            else G.addedge(N + j, G.T, V2[j]/V1[2], 0);
        G.min_cost_max_flow();
        if( res < -G.cost + val[1][i] ) {
            res = -G.cost + val[1][i]; ans[1] = i;
            for(int i=2;i<=N;i++) {
                int flag = N;
                for(edge *p=adj[i];p!=NULL;p=p->nxt)
                    if( p->to != G.S && p->flow == 1 ) flag = p->to;
                ans[i] = flag - N;
            }
        }
    }
    for(int i=1;i<=N;i++)
        printf("%d\n", ans[i]);
//  printf("%d\n", res);
}

至此，题解部分已经结束，下面是闲谈（可能对你有很大帮助）。

如果你认为这篇题解写的不错的话……动动手指，一键三连吧！👇👇👇

以下所有内容仅供参考，烧显卡本人不负责！

前置神力：

  • 一台 Windows10 或 Windows Server 2019 服务器
  • CPU：至少 Intel E5-2680V4（16 核心 32 线程）
  • 内存：至少 64 GiB
  • 显卡：至少 Nvidia Tesla P40 和一块 Nvidia Tesla M40（显存一共至少 24 GiB）
  • 以上条件为必要，可适当低配（如果没有，也可以继续看下去，有解决办法）。。
  • 网络：100Mbps 及以上下载带宽，可能需要科学上网（自行百度，不在文章范围。。）
插话：解决物理神力的问题

你得去一些云服务商租借 GPU云服务器，比如 35003500 一个月的阿里云或者一个月 待更新待更新 元，对学生党友好的雨云。

但……如果你没有零花钱（或者不知道云服务器怎么用），可以不用往下面看了……

正题：

众所周知，这题可以用模拟退火来做

这时间复杂度……O(n!)O(n!) 我都快疯了！！！，开了几个晚上啊！

我们可以考虑将程序挂载到 GPU 上运行（关键！！！）
插话：GPU 是什么东西？

GPU 就是 图形处理器 的缩写，它可以提供更高的并行运算能力，在 3D设计 游戏开发 图形处理中均有广泛的应用。

当然，GPU 也有他的缺点：价格过高、发热过猛、容易烧坏……

这是一张 GPU 价格一览表：

型号显存价格
Nvidia RTX 409024 GiB5050￥
Nvidia Tesla P4024 GiB1080￥
Nvidia Tesla K8024 GiB899￥
Nvidia Tesla M4024 GiB555￥
如何挂载到 GPU 上？

首先，我们来看一个 C++ 程序：

#include <bits/stdc++.h>
#include <cuda_runtime.h>
#include <cuda.h>
using namespace std;
int main() {
    ios :: sync_with_stdio(false);
    
    return 0;
}

其中的 #include <cuda_runtime.h> 就是调用 NvidiaNvidia 显卡的库文件，然后就可以挂载显卡了！！

别高兴，我们先得安装驱动~

进入这里，下载 CUDA 和显卡驱动程序，一定要选择对应的版本！

==注意：一定要选择离线版本，否则就只能魔法安装了！==

安装完成之后，就可以安装 Microsoft Visual Studio 2022 了，建议安装 20222022 版本，安装时注意选择跟 C++ 有关的所有模块。

安装完成后，我们测试一个程序，看看能不能正常运行：

#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
    ios :: sync_with_stdio(false);
    cin >> n;
    cout << n * n << endl;
    vector <int> a;
    int tmp;
    for (int i = 1; i <= n; i ++) {
        cin >> tmp;
        a . push_back(tmp);
    }
    cout << a . size() << endl;
    return 0;
}
测试 GPU 性能&改编程序

如果你的 GPU 不是前面所讲的，那么你可以将 Stable Diffusion 本地化部署：（具体在这里看教程）

如果你的电脑出一张 1024x1024 的图片在 10s 之内的话，就可以继续了~

改编程序：

#include<cmath>
#include<ctime>
#include<queue>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cuda.h>
#include<cuda_runtime.h>
using namespace std;
const int MAXN = 1000;
const int MAXM = 300;
const int INF = (1<<30);
int V1[MAXN + 5], V2[MAXN + 5], val[MAXN + 5][MAXM + 5];
int ans[MAXN + 5], tmp[MAXN + 5], nw[MAXN + 5], res = 0, N, M;
int get_ans() {
	int ret = 0, j = 1, re = V2[1];
	for(int i=1; i<=N; i++) {
		if( j > M ) tmp[nw[i]] = 0;
		else if( re >= V1[nw[i]] ) {
			tmp[nw[i]] = j, re -= V1[nw[i]];
			ret += val[nw[i]][j];
		} else j++, i--, re = V2[j];
	}
	return ret;
}
int real_ans[MAXN + 5], real_res = 0;
int main() {
	srand(time(NULL));
	freopen("drawer8.in", "r", stdin);
	scanf("%d%d", &N, &M);
	for(int i=1; i<=N; i++)
		scanf("%d", &V1[i]);
	for(int i=1; i<=M; i++)
		scanf("%d", &V2[i]);
	for(int i=1; i<=N; i++)
		for(int j=1; j<=M; j++)
			scanf("%d", &val[i][j]);
	while( true ) {
		for(int i=1; i<=N; i++)
			nw[i] = i;
		random_shuffle(nw + 1, nw + N + 1);
		res = get_ans();
		for(register double T=1E12; T>=1E-5; T*=0.986) {
			int x = rand() * 17 % N + 1, y = rand() * 17 % N + 1;
			swap(nw[x], nw[y]);
			if( get_ans() > res || 1.0/(1 + exp((res - get_ans())/T)) >= 1.0/rand() ) {
				for(int j=1; j<=N; j++)
					ans[j] = tmp[j];
				res = get_ans();
			} else swap(nw[x], nw[y]);
		}
		if( res > real_res ) {
			real_res = res;
			for(int i=1; i<=N; i++)
				real_ans[i] = ans[i];
			FILE *f = fopen("drawer8.out", "w");
			for(int i=1; i<=N; i++)
				fprintf(f, "%d\n", real_ans[i]);
			printf("%d\n", real_res);
		}
	}
}

==可以注意到，我们在每一个函数前面加上了一个 _即将更新_，就代表这个函数依附于 GPU 运行。==

同时，我们尝试将变量也该用 GPU显存，具体取决于你的电脑驱动了：

#include<cmath>
#include<ctime>
#include<queue>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cuda.h>
#include<cuda_runtime.h>
using namespace std;
const int MAXN = 1000;
const int MAXM = 300;
const int INF = (1<<30);
int V1[MAXN + 5], V2[MAXN + 5], val[MAXN + 5][MAXM + 5];
int ans[MAXN + 5], tmp[MAXN + 5], nw[MAXN + 5], res = 0, N, M;
int get_ans() {
	int ret = 0, j = 1, re = V2[1];
	for(int i=1; i<=N; i++) {
		if( j > M ) tmp[nw[i]] = 0;
		else if( re >= V1[nw[i]] ) {
			tmp[nw[i]] = j, re -= V1[nw[i]];
			ret += val[nw[i]][j];
		} else j++, i--, re = V2[j];
	}
	return ret;
}
int real_ans[MAXN + 5], real_res = 0;
int main() {
	srand(time(NULL));
	freopen("drawer8.in", "r", stdin);
	scanf("%d%d", &N, &M);
	for(int i=1; i<=N; i++)
		scanf("%d", &V1[i]);
	for(int i=1; i<=M; i++)
		scanf("%d", &V2[i]);
	for(int i=1; i<=N; i++)
		for(int j=1; j<=M; j++)
			scanf("%d", &val[i][j]);
	while( true ) {
		for(int i=1; i<=N; i++)
			nw[i] = i;
		random_shuffle(nw + 1, nw + N + 1);
		res = get_ans();
		for(register double T=1E12; T>=1E-5; T*=0.986) {
			int x = rand() * 17 % N + 1, y = rand() * 17 % N + 1;
			swap(nw[x], nw[y]);
			if( get_ans() > res || 1.0/(1 + exp((res - get_ans())/T)) >= 1.0/rand() ) {
				for(int j=1; j<=N; j++)
					ans[j] = tmp[j];
				res = get_ans();
			} else swap(nw[x], nw[y]);
		}
		if( res > real_res ) {
			real_res = res;
			for(int i=1; i<=N; i++)
				real_ans[i] = ans[i];
			FILE *f = fopen("drawer8.out", "w");
			for(int i=1; i<=N; i++)
				fprintf(f, "%d\n", real_ans[i]);
			printf("%d\n", real_res);
		}
	}
}

你可以尝试运行；如果没报错，恭喜，可以跳过解决方案！

编译器提示没有找到 cuda_runtime.h 的解决方案

[错误]cuda_runtime.h:Nosuchfileordirectory[错误]cuda_runtime.h:Nosuchfileordirectory

别着急，先看看你的驱动是否安装成功？驱动是否启动？显卡是否插好？==驱动版本是否匹配？？？==

（在前面提到过）

如果没问题？看看你的 Visual Studio 2022 编译器是否设置为 -std=c++20？==是否创建的是C++ CUDA 项目？？？==

若都没问题，可以重装 Microsoft Visual Studio 2022 了……

（看前面的安装过程）

如果还是不行，可以在评论留言或==仔细再看一遍教程==

如果还没有找到问题，可以==去开头项目文件中下载最新的项目文件和 exe测试文件，看看有没有问题。==

运行程序：

大概运行一周左右吧……

结果就出来了……

如何判断结果是否正确？

到 Loj 上去下载答案文件，==不要天真的以为那就是AC答案==

然后对比运行程序后输出在控制台而不是文件中的内容，看最后一个是否是你的程序比 Loj 的更大或相等，就可以了！

您可能感兴趣的与本文相关的镜像

Wan2.2-I2V-A14B

Wan2.2-I2V-A14B

图生视频
Wan2.2

Wan2.2是由通义万相开源高效文本到视频生成模型，是有​50亿参数的轻量级视频生成模型，专为快速内容创作优化。支持480P视频生成，具备优秀的时序连贯性和运动推理能力

Chat_lsm2024
关注
洛谷P1724题解（请不要抄袭！）
06-17
洛谷P1427题解，若要复制or下载，请与我联系，如要改编，也请联系，若发现未经我同意的复制、下载、改编，直接举报。
蓝桥杯C语言赛题-题解
最新发布
02-20
蓝桥杯C赛题-题解
洛谷 P6849 [THUWC2017] 大葱的神力 题解
zsr201276的博客
09-28 603
具体来说，我们生成物品的一个排列，然后贪心地将物品依次“尝试”放入 1~M 个背包，计算当前取得的最优值。这个代码的主体是费用流，所以可以复制上面的代码再稍微改改。，要不是因为这是题答，我还真不敢开这么大的数组。用模拟退火来生成排列就是一个很经典的应用了。T2，T8~10交给你们自己跑了。快乐一换三的代码，不要白不要。数据不大，自己写搜索吧！我电脑霍霍不起（逃）。
@loj - 2288@「THUWC 2017」大葱的神力
weixin_30670965的博客
01-07 880
目录 @description@ @solution@ @data - 1@ @data - 2@ @data - 3@ @data - 4@ @data - 5@ @data - 6@ @data - 7@ ...
LOJ 2288「THUWC 2017」大葱的神力
aozhuan8489的博客
12-25 585
LOJ 2288「THUWC 2017」大葱的神力 Link Solution 比较水的提交答案题了吧 第一个点爆搜 第二个点爆搜+剪枝，我的剪枝就是先算出 \(mx[i]\) 表示选取第 \(i \sim n\) 个物品所能达到的最大价值，如果当前价值加上后面一段的最大价值都打不到当前最大答案，那么返回 第三个点只有一个包，直接背包 \(f[i][j]\) 表示前 \(i\) 个物品占...
THUWC2017
12-29 226
100+20+20=140 还是很菜... T1 在美妙的数学王国中畅游 一棵树每个点有一个函数（sin，exp，一次函数），支持加边，删边，单点修改，查询一条路径在 $x$ 处的点值和 sol： 题面都给了泰勒展开...那就展吧 展 10 项就可以过，因为时限很松，展 10~20 都是可以的，LCT 维护一下 T2 随机二分图 有一个二分图，三种边对 1.A 边...
thuwc2017滚粗记
jr_mz的博客
02-12 1090
开幕讲话一言不合讲到恋爱很滑稽啊？ 试机题目非常因吹斯听啊？ 考试题目怎么有点妙啊？ 第一题怎么提示里给了泰勒展开公式啊？ 那我们把各种函数强行泰勒展开就可以很容易的维护了啊？ 那就是一个裸lct了啊？ 那我要是A了第一题岂不是美滋滋？ 我怎么lct也码挂了啊？ 感觉不一定有希望调出来啊？ 不如码个线段树拿拿55分？ 第二题感觉是个很高明的计数题啊？ 后来果然是陈老师的题啊？
完美世界2017校园招聘编程题-题解
10-12
有利于大家准备学习的pdf，明白2017年完美世界校园招聘所考的内容。
旅行商问题-使用启发式算法解决旅行商问题-题解-大作业.zip
02-08
旅行商问题 旅行商问题_使用启发式算法解决旅行商问题_题解_大作业
美赛数学建模算法-使用Matlab实现启发式算法-包括模拟退火+神经网络+遗传算法-国赛-题解.zip
05-22
美赛数学建模算法_使用Matlab实现启发式算法HeuristicAlgorithm_包括模拟退火+神经网络+遗传算法_国赛_题解
CCF WC2017 冬令营 课件集合 （圆方树等）
12-25
CCF WC2017 课件集合 （圆方树等） CCF WC2017 课件集合 （圆方树等） CCF WC2017 课件集合 （圆方树等）
[LOJ#2289 && BZOJ5020][THUWC 2017]在美妙的数学王国中畅游
CE玩家
07-02 1263
终于找到一个可以交的地方了… 考场上只写了LCT的60分暴力，因为那时候并看不懂什么泰勒展开…前段时间学了微积分，学了泰勒展开，大概知道了是怎么回事 其实题目说的很清楚了…但是那时候就是看不懂，也不会求导什么的。讲sin(ax+b)\sin(ax+b),eax+be^{ax+b}和ax+bax+b在x=0处展开可以得到： sin(ax+b)=sin(b)+acos(b)x1!−a2sin(
WC2017&THUWC2017 游记
LiuJunhao's Blog
02-16 3013
我可能去了假的WC QAQ 人世几回伤往事，山形依旧枕寒流。day1报到日，然而我们学校从重庆坐火车去绍兴，完美错过开幕式day2上午鏼鏼鏼讲字符串，勉强听懂前半截。 下午rzz的猜数游戏，尛焱轟讲IOI2016试题，勉强跟上节奏。 从晚上的营员交流开始，冬眠营正式拉开序幕。 myy的Berlekamp Massey算法，从头开始懵逼 敦敦敦的30KB神题彻底将我催眠，接下来的仙人掌计数在
[TravelNotes] WC 2017 & THUWC 2017 游记
雯舞
02-12 2416
Pre() 春节在家 赶紧临时抱佛脚一发 学习杜教筛和SAM 刷刷模板题 水水水 还想起自己数据结构的姿势水平不高啊 恶补了一下 替罪羊树 线段树分裂 二进制分组 然后重新学习了LCT的姿势 再看看自己以前码的LCT真是丑的不行 某些天晚些时候 恰好有比赛 就打了打CF BC 还有 Goodbye Bingshen 某天被dls安利到vjudge打了一场ABC53/ARC68的复现赛 被d...
WC2017咸鱼记&THUWC2017垫底记
不来也不去的一只失忆蝴蝶
02-09 3544
DAY -3来到杭州 下午一直和张棍格斗 晚上走了n久找不到饭吃，还冻成了dogDAY -2早上模拟赛因为账号权限没了所以啥都不记得了 讨论完试题只有1h给我们洗澡/吃饭 洗完澡去买了个汉堡 晚上继续做模拟赛，假老师的题贼毒，我20分就是高分选手DAY -1早上做的全程倦生，因为肚子好疼啊 这个持续了一天，估计是冷的原因 晚上可以自由做题就去刷了一下luogu月赛。DAY 0早上继续做
THUWC2017 酱油记
lych的博客
02-11 1863
从绍一滚到了学军，，持续滚粗之旅。 day -1 辗转到了绍一（1h的公交好累啊），已经19:00+了，然后进入学军报道，去了一趟寝室感觉好大啊，比某镇上的中学高到不知道哪里去了。当年ZJOI看宣传片的时候以为是ps的，现在发现居然是真的这么好。 于是20:00左右噎了晚饭，可惜由于肚子不舒服不能噎很多。。。qaq 晚上终于可以洗澡了，浑身舒爽。 day 1 5:00被冻醒，被
[LOJ#2290][THUWC 2017][概率][状压][DP][陈老师神题]随机二分图
CE玩家
07-04 1692
又是一个冬令营未填的坑可以根据期望的直接定义，求出每个完美匹配出现的概率。 因为n很小，可以状压DP，fs,tf_{s,t}表示左边被匹配的状态为ss，右边被匹配的状态为tt时的概率，因为左右边被匹配的点个数是相同的，所以状态数大概为∑Cin2\sum {C^i_n}^2？？？但是肯定远远比这个小。然后直接做不太容易实现 可以把两条边的组拆分。 同时出现的组 可以拆成两条50%的边，以及25%
THUWC2017 瞎搞记
neither_nor
02-15 2759
DAY-1 上午去WC的社会实践搞搞搞 晚上和昌老师，jkxing还有fzw一起坐着大巴去学车 报了一会道进了宿舍 卧槽这个宿舍怎么这么高级！ 门是刷卡的！ 各种开关是触控的！ 每个屋配淋浴间和厕所阳台，两个手盆！ 有插座和台灯桌子！ 有wifi！虽然连不上-_- 比之前住过的宿舍都不知高到哪里去了 认识了一下同寝的四位神犇，全是四川的，象征性地问了一下名字，反正记不住-_-
【LOJ #2290】「THUWC 2017」随机二分图（状压DP）
Stargazer的博客
11-07 230
传送门 暴力的做法是设f[s1][s2]f[s1][s2]f[s1][s2]为左右匹配状态转移 考虑对于第二类 拆成两条独立的，出现概率为50%50\%50%的边 但是一起出现的概率少了25%25\%25% 可以再加一个一起出现的25%25\%25%的情况 第三类类似 加一个一起出现为−25%-25\%−25%的情况 然后暴力dpdpdp，用mapmapmap存状态 每次匹配标号最小的一个点 这样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值