HDU 3339 In Action 最短路+01背包

最新推荐文章于 2024-08-17 03:35:19 发布
最新推荐文章于 2024-08-17 03:35:19 发布
阅读量160 收藏 1
点赞数
分类专栏： 背包问题 dp 动态规划 最短路径
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiji333/article/details/88917401
版权

http://acm.hdu.edu.cn/showproblem.php?pid=3339

 

Since 1945, when the first nuclear bomb was exploded by the Manhattan Project team in the US, the number of nuclear weapons have soared across the globe.
Nowadays,the crazy boy in FZU named AekdyCoin possesses some nuclear weapons and wanna destroy our world. Fortunately, our mysterious spy-net has gotten his plan. Now, we need to stop it.
But the arduous task is obviously not easy. First of all, we know that the operating system of the nuclear weapon consists of some connected electric stations, which forms a huge and complex electric network. Every electric station has its power value. To start the nuclear weapon, it must cost half of the electric network's power. So first of all, we need to make more than half of the power diasbled. Our tanks are ready for our action in the base(ID is 0), and we must drive them on the road. As for a electric station, we control them if and only if our tanks stop there. 1 unit distance costs 1 unit oil. And we have enough tanks to use.
Now our commander wants to know the minimal oil cost in this action.

Input

The first line of the input contains a single integer T, specifying the number of testcase in the file.
For each case, first line is the integer n(1<= n<= 100), m(1<= m<= 10000), specifying the number of the stations(the IDs are 1,2,3...n), and the number of the roads between the station(bi-direction).
Then m lines follow, each line is interger st(0<= st<= n), ed(0<= ed<= n), dis(0<= dis<= 100), specifying the start point, end point, and the distance between.
Then n lines follow, each line is a interger pow(1<= pow<= 100), specifying the electric station's power by ID order.

Output

The minimal oil cost in this action.
If not exist print "impossible"(without quotes).

Sample Input

2
2 3
0 2 9
2 1 3
1 0 2
1
3
2 1
2 1 3
1
3

Sample Output

5
impossible

题目大意：给n个点和m条边，每个点有一个能量站，能量站有ai的能量，你有无数辆坦克可以从点0出发，你需要摧毁一些能量站使得这些能量站的总和大于等于总能量的一半，但是你的坦克每移动1m就要消耗1L升油，让你求出可以完成要求的最少油量，若不可能则输出impossible。

思路：最短路+01背包。这道题的数据有重边！！！让我找bug找了好久。(心态大崩)背包应该是有两种方法的：(1)把距离当做背包容量，每个点的能量当做价值，做01背包，同时记录价值大于等于能量一半的情况下所花费的最小容量。(2)把能量当做背包容量，到每个点的距离当做价值，做01背包，同时记录消耗背包体积大于等于总体积一半情况下所获得的最小价值。提供四种方法吧。

floyd+第一种背包方法：

#include<iostream>
#include<cstdio>
#include<stack>
#include<cmath>
#include<cstring>
#include<queue>
#include<set>
#include<algorithm>
#include<iterator>
#define INF 0x3f3f3f3f
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int s[105][105];
int a[105];
int dp[100005];
int n,m;

void floyd()
{
    for(int k=0;k<=n;k++)
        for(int i=0;i<=n;i++)
            for(int j=0;j<=n;j++)
                s[i][j]=min(s[i][j],s[i][k]+s[k][j]);
}
int main()
{
    int t;
    scanf("%d",&t);
	while(t--)
	{
		int b,e,v;
		memset(s,INF,sizeof(s));
		for(int i=0;i<=n;i++)
            s[i][i]=0;
		scanf("%d %d",&n,&m);
		for(int i=0;i<m;i++)
		{
			scanf("%d %d %d",&b,&e,&v);
            if(s[b][e]>v)
                s[b][e]=s[e][b]=v;
		}
		floyd();
		int sum=0,MAX=0;
		for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
            if(s[0][i]!=INF)
                MAX+=s[0][i];
        }
        memset(dp,0,sizeof(dp));
        sum/=2;
        int MIN=INF;
        for(int i=1;i<=n;i++)
        {
            for(int j=MAX;j>=s[0][i];j--)
            {
                dp[j]=max(dp[j],dp[j-s[0][i]]+a[i]);
                if(dp[j]>sum)
                    MIN=min(MIN,j);
            }
        }
        if(MIN==INF)
            printf("impossible\n");
        else
            printf("%d\n",MIN);
	}
	return 0;
}

floyd+ 第二种背包方法：

#include<iostream>
#include<cstdio>
#include<stack>
#include<cmath>
#include<cstring>
#include<queue>
#include<set>
#include<algorithm>
#include<iterator>
#define INF 0x3f3f3f3f
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int s[105][105];
int a[105];
int dp[100005];
int n,m;

void floyd()
{
    for(int k=0;k<=n;k++)
        for(int i=0;i<=n;i++)
            for(int j=0;j<=n;j++)
                s[i][j]=min(s[i][j],s[i][k]+s[k][j]);
}
int main()
{
    int t;
    scanf("%d",&t);
	while(t--)
	{
		int b,e,v;
		memset(s,INF,sizeof(s));
		for(int i=0;i<=n;i++)
            s[i][i]=0;
		scanf("%d %d",&n,&m);
		for(int i=0;i<m;i++)
		{
			scanf("%d %d %d",&b,&e,&v);
            if(s[b][e]>v)
                s[b][e]=s[e][b]=v;
		}
		floyd();
		int sum=0;
		for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        memset(dp,INF,sizeof(dp));
        dp[0]=0;
        int MIN=INF;
        for(int i=1;i<=n;i++)
        {
            for(int j=sum;j>=a[i];j--)
            {
                dp[j]=min(dp[j],dp[j-a[i]]+s[0][i]);
                if(j>sum/2)
                    MIN=min(MIN,dp[j]);
            }
        }
        if(MIN==INF)
            printf("impossible\n");
        else
            printf("%d\n",MIN);
	}
	return 0;
}

dijkstra+ 第一种背包方法：

#include<iostream>
#include<cstdio>
#include<stack>
#include<cmath>
#include<cstring>
#include<queue>
#include<set>
#include<algorithm>
#include<iterator>
#define INF 0x3f3f3f3f
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

int s[105][105];
int d[105];
int a[105];
int vis[105];
int dp[100005];
int n,m;

void dijkstra()
{
    memset(vis,0,sizeof(vis));
    memset(d,INF,sizeof(d));
    d[0]=0;
    while(1)
    {
        int u=-1,MIN=INF;
        for(int i=0;i<=n;i++)
        {
            if(!vis[i]&&d[i]<MIN)
            {
                MIN=d[i];
                u=i;
            }
        }
        if(u==-1)
            break;
        vis[u]=1;
        for(int i=0;i<=n;i++)
            if(!vis[i]&&d[i]>d[u]+s[u][i])
                d[i]=d[u]+s[u][i];
    }
}

int main()
{
    int t;
    scanf("%d",&t);
	while(t--)
	{
		int b,e,v;
		memset(s,INF,sizeof(s));
		scanf("%d %d",&n,&m);
		edge temp;
		for(int i=0;i<m;i++)
		{
			scanf("%d %d %d",&b,&e,&v);
            if(s[b][e]>v)
                s[b][e]=s[e][b]=v;
        }
		dijkstra();
		int sum=0,MAX=0;
		for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
            if(d[i]!=INF)
                MAX+=d[i];
        }
        memset(dp,0,sizeof(dp));
        sum/=2;
        int MIN=INF;
        for(int i=1;i<=n;i++)
        {
            for(int j=MAX;j>=d[i];j--)
            {
                dp[j]=max(dp[j],dp[j-d[i]]+a[i]);
                if(dp[j]>sum)
                    MIN=min(MIN,j);
            }
        }
        if(MIN==INF)
            printf("impossible\n");
        else
            printf("%d\n",MIN);
	}
	return 0;
}

堆优化dijkstra+ 第一种背包方法：

#include<iostream>
#include<cstdio>
#include<stack>
#include<cmath>
#include<cstring>
#include<queue>
#include<set>
#include<algorithm>
#include<iterator>
#define INF 0x3f3f3f3f
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

struct edge
{
    int to,v;
};

struct node
{
    int dis;
    int id;
    bool operator <(const node&a)const
    {
        return dis>a.dis;
    }
};

vector<edge> vec[105];
int d[105];
int a[105];
int vis[105];
int dp[100005];
int n,m;

void dijkstra()
{
    memset(vis,0,sizeof(vis));
    memset(d,INF,sizeof(d));
    d[0]=0;
    node t;
    t.id=0,t.dis=0;
    priority_queue<node> q;
    q.push(t);
    while(!q.empty())
    {
        node h=q.top();
        q.pop();
        int id=h.id;
        if(d[id]<h.dis)
            continue;
        for(int i=0;i<vec[id].size();i++)
        {
            int to=vec[id][i].to;
            if(d[to]>d[id]+vec[id][i].v)
            {
                d[to]=d[id]+vec[id][i].v;
                node temp;
                temp.id=to;
                temp.dis=d[to];
                q.push(temp);
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d",&t);
	while(t--)
	{
		int b,e,v;
		scanf("%d %d",&n,&m);
		for(int i=0;i<=n;i++)
            while(vec[i].size())
                vec[i].pop_back();
		edge temp;
		for(int i=0;i<m;i++)
		{
			scanf("%d %d %d",&b,&e,&v);
            temp.v=v;
            temp.to=e;
            vec[b].push_back(temp);
            temp.to=b;
            vec[e].push_back(temp);
        }
		dijkstra();
		int sum=0,MAX=0;
		for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
            if(d[i]!=INF)
                MAX+=d[i];
        }
        memset(dp,0,sizeof(dp));
        sum/=2;
        int MIN=INF;
        for(int i=1;i<=n;i++)
        {
            for(int j=MAX;j>=d[i];j--)
            {
                dp[j]=max(dp[j],dp[j-d[i]]+a[i]);
                if(dp[j]>sum)
                    MIN=min(MIN,j);
            }
        }
        if(MIN==INF)
            printf("impossible\n");
        else
            printf("%d\n",MIN);
	}
	return 0;
}

 

csu_xiji
关注
专栏目录
hdu3339 In Action 最短路+01背包
ijbuhv的专栏
08-01 677
//有n个电站，每一个电站能提供不同的power， //所有tank从0点出发，停在该电站就代表摧毁了该电站，tank从电站到电站之间需要耗费能量 //现在有无穷的tank,问最少需要耗费多少油能够摧毁一半以上的power //先用dijkstra求得到每个点的dis[i] //然后用一个01背包得到答案 #include<cstdio> #include<cstring> #include<ios
hdu 3339 In Action 最短路+01背包
03-10 701
题意：n个点m条边的无向图，点和边都有权值。 反复从0点出发，求获得大于点总权值一半的边的边权和。 因为只有100个点，所以直接floyd求最短路，然后一次01背包，DP[i]表示消耗i的油能摧毁的最多的电力。 #include #include #include using namespace std; #define INF 0x3f3f3f3f int n,m,a,b,c; in
hdu3339In Action(最短路+01背包）
最新发布
weixin_41042122的博客
08-17 21
http://acm.sdut.edu.cn:8080/vjudge/contest/view.action?cid=259#problem/HDescriptionSince 1945, when the first nuclear bomb was exploded by the Manhattan Project ...
hdu 3339 In Action 最短路spfa+背包
弱菜zc
04-04 1246
题目链接 题意：给出n个点及每个点的电力值，给出m条路。选取若干个点，在保证其电力值之和大于总电力值的一半的情况下求其最短路径和。 先求出初始点到每个点的最短路径，然后用背包的思想选取若干个点，使距离和最小。注意每个坦克只能到一个点。 #include #include #include #include #include #define N 110 #define M 11000 #de
HDU3339 In Action（最短路+01背包）
FILWY_M
07-19 125
题目传送门：In Action 分析题意：读题读不懂真的很难受，真的是要死了。来分析一下题意吧，这个题的意思就是说一共有n个电站，然后坦克都在起始位0的位置，我们要从0这个位置分别派坦克去摧毁电站（注意：每个坦克只能摧毁一个电站，所以要摧毁多少个电站我们就要多少坦克，重点是他们都是从0位置出发，这个时候的最小油量不就是从0到下一个位置的最短路吗？？？）此题的n<=100，比较小，所以我们可...
In Action HDU - 3339 （最短路+01背包）
FLY_WHITE的博客
08-08 163
  Since 1945, when the first nuclear bomb was exploded by the Manhattan Project team in the US, the number of nuclear weapons have soared across the globe.  Nowadays,the crazy boy in FZU named AekdyCo...
HDU 3339 In Action 最短路+01背包~
weixin_30896763的博客
08-15 83
题目大意就是 你有足够多的坦克，让你用尽量多的坦克去占领电厂。有N+1各节点，0~n ，0为出发点，1~n为电厂。要想控制摧毁电厂，战胜对方，只需要占领一般的电量即可。但是特克会耗油，所一给你m条路，让你去计算最小耗电量~而且如果坦克不能通过m条路到达任意一个电厂的话就输出'impossible' 连接：http://acm.hdu.edu.cn/showproblem.php?pid=3339...
HDU - 3339 In Action （最短路+01背包）
01232012的博客
10-22 140
简述题意： 给出N个供电站编号从1~N,然后给出M条边：并且给出这N个供电站的电量。每辆坦克从基地出发去攻击供电站，并且每辆坦克只能攻击一个供电站，求要使的破坏总电量的一半以上，求这些坦克要走的最短距离。   难度：NOIP 算法：首先，从基地跑一次最短路，求出到所有供电站的距离，接下来就是01背包了！ 所有供电站的电量总和为-&gt;背包容量 每个供电站为-&gt;背包中的物品 每...
HDU3339 In Action(Dijkstra+01背包）
WTMDNM_的博客
07-26 166
题目链接 In Action Since 1945, when the first nuclear bomb was exploded by the Manhattan Project team in the US, the number of nuclear weapons have soared across the globe. Nowadays,the crazy boy in FZU named AekdyCoin possesses some nuclear weapons and wanna
hdu 1695 GCD（欧拉函数+容斥原理）.docx
10-29
"hdu 1695 GCD（欧拉函数+容斥原理）" 题目大意是：给定 a, b, c, d, k，找到一队 x, y，满足 g(x, y) = k，且 x ∈ [1, b], y ∈ [1, d]，问有多少对符合要求的 (x, y)。 思路是：gcd(x, y) == k 解释 x, y 都能...
【HDU 3993】田忌赛马 题解+勘误
12-14
【田忌赛马】是一道源自古代中国历史的著名策略问题，被转化为计算机科学中的算法题目，出现在HDU（杭州电子科技大学在线评测系统）的3993号问题中。该题目的主要目的是通过编程来解决如何在不确定的对手策略下，...
HDU 1428 漫步校园（最短路+记忆化搜索）
AC_Dreameng
07-14 2478
漫步校园 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 3991    Accepted Submission(s): 1235 Problem Description LL最近沉迷于AC不能自拔，每天寝室、机房
CSU 2257 Intergalactic Bidding 超递增背包+大数
xiji333的博客
05-02 884
http://acm.csu.edu.cn:20080/csuoj/problemset/problem?pid=2257 Description Today the Intergalactic Council of Pebble Coins (ICPC) conducted an intergalactic auction of the Neutronium Chaos Pebble Coi...
背包九讲 附Acwing模板题AC代码
xiji333的博客
02-09 745
文章目录推荐博客010101背包完全背包多重背包朴素版二进制优化单调队列优化混合背包二维费用背包问题分组背包有依赖背包问题泛化物品背包问题问法的变化输出字典序最小的最优方案输出最优解的方案数第kkk优解 推荐博客 背包九讲原文 背包九讲——全篇详细理解与代码实现 本博客对基础内容不进行解释，基础薄弱的可以与上述博客一起食用。 010101背包 例题 #include<bits/stdc++....
力扣 1449. 数位成本和为目标值的最大数字 dp 贪心
xiji333的博客
06-12 546
https://leetcode-cn.com/problems/form-largest-integer-with-digits-that-add-up-to-target/ 思路一：依旧是完全背包的变种……只不过这道题要求恰好装满背包，那么在初始化的时候只初始化dp0dp_0dp0​为空，其余的初始化为−∞-\infin−∞即可。但是此题需要比较的元素是字符串而不是整数，而且字符串的比较方式也有所区别：首先判断长度关系，然后逐字符判断。如果简单的认为dpdpdp数组每个元素都是字符串，然后按照如下方程
Round A 2020 - Kick Start 2020 Plates dp 分组背包
xiji333的博客
03-22 382
https://codingcompetitions.withgoogle.com/kickstart/round/000000000019ffc7/00000000001d40bb #include<bits/stdc++.h> #define INF 0x3f3f3f3f using namespace std; typedef long long ll; const int ...
洛谷 P1855 二维费用的背包问题
xiji333的博客
02-25 379
https://www.luogu.org/problemnew/show/P1855 题目描述 洛谷2的团队功能是其他任何oj和工具难以达到的。借助洛谷强大的服务器资源，任何学校都可以在洛谷上零成本的搭建oj并高效率的完成训练计划。 为什么说是搭建oj呢？为什么高效呢？ 因为，你可以上传私有题目，团队外别人是无法看到的。我们还能帮你们评测！ 你可以创建作业，给组员布置任务，查看组员...
洛谷 P1802 5倍经验日 dp
xiji333的博客
04-16 284
https://www.luogu.com.cn/problem/P1802 思路：010101背包的简单变形吧，有两种决策：dp[j]=max(dp[j]+lose[i],dp[j−use[i]]+win[i])dp[j]=max(dp[j]+lose[i],dp[j-use[i]]+win[i])dp[j]=max(dp[j]+lose[i],dp[j−use[i]]+win[i]) #inc...
2013年HDU专题：最短路径与背包问题训练
"HDU 专题分类（2013年8月）"是一场由webDIY和DIY组织的线上编程竞赛，针对ACM（Adaptive Computation and Machine Learning）问题提供了一系列的题目，旨在提升参赛者的算法设计和问题解决能力。这个专题训练涵盖了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值