《动态规划》Problem F. 最勇敢的机器人

Problem F. 最勇敢的机器人

时间限制 1000 ms
内存限制 128 MB

题目描述

机器人们都想知道谁是最勇敢的，于是它们比赛搬运一些物品。
它们到了一个仓库，里面有n个物品，每个物品都有一个价值Pi和重量Wi，但是有些物品放在一起会爆炸，并且爆炸具有传递性。（a和b会爆炸、b和c会爆炸则a和c会爆炸）
机器人们可不想因此损失自己好不容易从Wind那里敲诈来的装备，于是它们想知道在能力范围内，它们最多可以拿多少价值的物品。
你能帮助它们吗？

输入数据

每组测试数据
第 11 行为 n,Wmax,k (0≤n,Wmax,k≤1000)n,Wmax,k (0≤n,Wmax,k≤1000) 
接下来 nn 行，为每个物品的 Pi,Wi (0≤Pi≤1000,1≤Wi≤10,Pi,Wi (0≤Pi≤1000,1≤Wi≤10, 均为整数)
再接下来 kk 行，每行 22 个数字 a,ba,b 表示 aa 和 bb 会发生爆炸

输出数据

对每组数据输出 11 行
为最大可能价值

样例输入

3 10 1
100 1
200 5
10 5
1 2

样例输出

210

思路解析：

先并查集确定划分为组，然后根据每组的情况，进行0,1背包问题的动态规划。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<string>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<cmath>
#include<vector>
#include<string>
#define INF 0x7FFFFFFF //int 最大值
#define maxSize 1000

using namespace std;

int n,Wmax,k,sum;
int root[maxSize+5];
int dp[maxSize+5][maxSize+5];
int a,b;//输入放在一起会爆炸的项
struct Good{
    int p;
    int w;
};
Good good[maxSize+5];
vector<vector<int>>rIndex;//rIndex不是很紧凑的Vector
vector<vector<int>>Index;//紧凑Vector

int findRoot(int x)
{
    while(x!=root[x])
        x=root[x];
    return x;
}
void unionNode(int x,int y)
{
    int rootX=findRoot(x);
    int rootY=findRoot(y);
    if(rootX!=rootY)
        root[rootX]=rootY;
    return;
}


int main()
{
    cin>>n>>Wmax>>k;

    //并查集分类
    for(int i=1;i<=n;i++)//从1开始
    {
        cin>>good[i].p>>good[i].w;
        root[i]=i;
    }
    for(int i=0;i<k;i++)
    {
        cin>>a>>b;
        unionNode(a,b);
    }

    //将所有的物品按根节点划分
    for(int i=0;i<=n;i++)//初始化
    {
        vector<int>v;
        rIndex.push_back(v);
    }
    for(int i=1;i<=n;i++)//将所有root相同的点保存到一个vector中
        rIndex[findRoot(i)].push_back(i);

    for(int i=0;i<=n;i++)//为便于访问，此时，将vector紧凑化 显然Index.size()就是所有可被选择的物品的数量，可能对于某个物品有多个互斥的候选
    {
        if(rIndex[i].size()==0)
            continue;
        Index.push_back(rIndex[i]);
    }

    //动态规划 背包问题
    for(int i=0;i<n;i++)//初始化dp数组
    {dp[i][0]=0;dp[0][i]=0;}

    for(int i=1;i<=Index.size();i++)
    {
        for(int j=1;j<=Wmax;j++)
        {
            dp[i][j]=dp[i-1][j];
            for(int k=0;k<Index[i-1].size();k++)//用每一个可能的选项更新dp vector从0开始
                if(j>=good[Index[i-1][k]].w)
                    dp[i][j]=max(dp[i][j],dp[i-1][j-good[Index[i-1][k]].w]+good[Index[i-1][k]].p);
        }
    }

    cout<<dp[Index.size()][Wmax]<<endl;
    return 0;
}

 再提一点：

思路简单，就是划分组的时候，需要注意一下，Vector真的好用。