HDU 3339 In Action

最新推荐文章于 2024-08-17 03:35:19 发布

原创最新推荐文章于 2024-08-17 03:35:19 发布 · 136 阅读

0 ·

CC 4.0 BY-SA版权

图论同时被 2 个专栏收录

67 篇文章

订阅专栏

动态规划

54 篇文章

订阅专栏

本文探讨了一种结合01背包问题与最短路径算法的创新方法，通过预处理最短路径并利用01背包算法求解至少装一半以上物品的最小价值问题。在无向图中，每件物品的价值由起点到该点的最短路径决定，物品的重量为点的能量值。文章详细介绍了如何使用Dijkstra算法求最短路径，以及如何进行01背包的逆向求解。

传送门

01背包。预先求解一下最短路+求至少装一半以上（不包含一半）的最小价值。
给你一个无向图，每件物品的价值是起点到这个点的最短路值，每个物品的重量是这个点的能量值，注意，这道题所说的是坦克一直停在那个点才占有那个点的能量值，不是一辆坦克走一圈。。。所以这就好办多了，直接用背包了。

这道题要求至少装一半以上，这个我们先按照恰好装满来求解，然后枚举每个容量>= V/2+1的背包值然后取最小的就好了。因为真实解一定是恰好装满某个容量的背包值。


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <string>
#include <queue>
using namespace std;

const int MAXN = 101;
const int INF = 1e9;
int T, N, M;
int power[MAXN];

struct Edge
{
	int n;
	int w;
};
struct Node
{
	int n, d;
	Node(int _n, int _d) :n(_n), d(_d) {}
	bool operator<(const Node& n0) const
	{
		return d > n0.d;
	}
};
vector<Edge> ve;
vector<int> v[MAXN];
int d[MAXN];
bool vis[MAXN];

int V;                          // 总能量值，相当与背包容量
int dp[10001];                  // 100*100，背包容量最大是10000
int ans;

void init()
{
	ve.clear();
	for (int i = 0; i <= N; i++) v[i].clear();
	V = 0;

	fill(dp, dp + 10001, INF);                            // 按照最小价值恰好装满来求
	dp[0] = 0;                                            //

	ans = INF;
}

void dijkstra(int s)
{
	memset(vis, 0, sizeof vis);
	fill(d, d + N + 1, INF);
	d[s] = 0;

	priority_queue<Node> q;
	q.push(Node(s, d[s]));
	for (; !q.empty();)
	{
		Node u = q.top();
		q.pop();
		if (vis[u.n]) continue;
		vis[u.n] = true;

		for (int j = 0; j < v[u.n].size(); j++)
		{
			int n = ve[v[u.n][j]].n;
			int w = ve[v[u.n][j]].w;
			if (!vis[n] && u.d + w < d[n])
			{
				d[n] = u.d + w;
				q.push(Node(n, d[n]));
			}
		}
	}
}

int main()
{
	int a, b, c;
	scanf("%d", &T);
	for (; T--;)
	{
		scanf("%d%d", &N, &M);
		init();
		for (int i = 0; i < M; i++)
		{
			scanf("%d%d%d", &a, &b, &c);
			ve.push_back(Edge{ b,c });
			ve.push_back(Edge{ a,c });
			v[a].push_back(i << 1);
			v[b].push_back(i << 1 | 1);
		}
		for (int i = 1; i <= N; i++)
		{
			scanf("%d", &power[i]);
			V += power[i];
		}
		dijkstra(0);

		for (int i = 1; i <= N && d[i] != INF; i++)             // 这些点到不了，这些物品无效
		{
			for (int j = V; j >= power[i]; j--)                 // 01背包逆向
			{
				dp[j] = min(dp[j], dp[j - power[i]] + d[i]);    // 求的是最小价值
			}
		}
		for (int i = V; i >= (V / 2) + 1; i--)                  // 枚举一个个大于一半容量的背包值，找最小的
			ans = min(ans, dp[i]);

		if (ans == INF) printf("impossible\n");                 // 不可能恰好装满的值都是+INF不变（最小值的恰好装满）
		else printf("%d\n", ans);
	}

	return 0;
}