2019 ACM/ICPC Asia Regional shanxia D Miku and Generals (二分图黑白染色+01背包)

Miku is matchless in the world!” As everyone knows, Nakano Miku is interested in Japanese generals, so Fuutaro always plays a kind of card game about generals with her. In this game, the players pick up cards with generals, but some generals have contradictions and cannot be in the same side. Every general has a certain value of attack power (can be exactly divided by 100100 ), and the player with higher sum of values will win. In this game all the cards should be picked up.

This day Miku wants to play this game again. However, Fuutaro is busy preparing an exam, so he decides to secretly control the game and decide each card's owner. He wants Miku to win this game so he won't always be bothered, and the difference between their value should be as small as possible. To make Miku happy, if they have the same sum of values, Miku will win. He must get a plan immediately and calculate it to meet the above requirements, how much attack value will Miku have?

As we all know, when Miku shows her loveliness, Fuutaro's IQ will become 00 . So please help him figure out the answer right now!

Input

Each test file contains several test cases. In each test file:

The first line contains a single integer T(1 \le T \le 10)T(1≤T≤10) which is the number of test cases.

For each test case, the first line contains two integers: the number of generals N(2 \le N \le 200)N(2≤N≤200) and thenumber of pairs of generals that have contradictions⁡ M(0 \le M \le 200)M(0≤M≤200).

The second line contains NN integers, and the ii-th integer is c_ici​, which is the attack power value of the ii-th general (0 \le c_i \le 5\times 10^4)(0≤ci​≤5×104).

The following MM lines describe the contradictions among generals. Each line contains two integers AA and BB , which means general AA and BB cannot be on the same side (1 \le A , B \le N)(1≤A,B≤N).

The input data guarantees that the solution exists.

Output

For each test case, you should print one line with your answer.

Hint

In sample test case, Miku will get general 22 and 33 .

样例输入复制

1
4 2
1400 700 2100 900
1 3
3 4

样例输出复制

2800

题意：给你n个数，让你分成两堆，堆与堆之间的和的差值最小，中间值与值之间可能存在矛盾，不能分在同一组，问你分配后最大的那一组的值是多少
思路：首先我们知道很多矛盾对，但是有可能一个人与多个人都有矛盾，所以为了避免分组的时候发生矛盾，我们很容易就想到二分图的黑白染色，这样我们首先就可以
解决矛盾问题，然后我们要每个联通块，我们首先可以求所有的和2x,那么x肯定是最优情况，我们又再每个连通块里面选最小的值，和就是y，（一个数为连通块时，另一个就是0，设计巧妙的地方），
然后我们要使y更接近x,所以我们就求x-y的容量，在每个连通块的差值里面选多少交换来求最大，然后这里就相当于转换为一个01背包问题

#include<bits/stdc++.h>
#define maxn 100005
#define mod 1000000007
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll n,m;
ll a[maxn],b[maxn];
vector<int> mp[maxn];
ll s,dp[maxn];
int vis[maxn];
void dfs(int x,int num){
    vis[x]=s+num;
    for(int i=;i<mp[x].size();i++){
        if(vis[mp[x][i]]==){
            if(num==){
                dfs(mp[x][i],);
            }
            else{
                dfs(mp[x][i],);
            }
        }
    }
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        for(int i=;i<maxn;i++) mp[i].clear();
        scanf("%lld%lld",&n,&m);
        for(int i=;i<=n;i++){
            scanf("%lld",&a[i]);
            a[i]/=;
        }
        int x,y;
        for(int i=;i<m;i++){
            scanf("%d%d",&x,&y);
            mp[x].push_back(y);
            mp[y].push_back(x);
        }
        s=;
        memset(vis,,sizeof(vis));
        for(int i=;i<=n;i++){
            if(vis[i]==){
                dfs(i,);
                s+=;
            }
        }
        s--;
        ll sum=,num=;
        memset(b,,sizeof(b));
        for(int i=;i<=n;i++){
            b[vis[i]]+=a[i];
            sum+=a[i];
        }
        int q=;

        for(int i=;i<=s;i+=){
            num+=min(b[i],b[i+]);
            b[q++]=abs(b[i]-b[i+]);
        }
        ll z=sum/+sum%;
        z-=num;
        memset(dp,,sizeof(dp));
        for(int i=;i<q;i++){
            for(int j=z;j>=b[i];j--){
                dp[j]=max(dp[j],dp[j-b[i]]+b[i]);
            }
        }
        ll z1=num;
        if(dp[z] != -) z1+=dp[z];
        ll z2=sum-z1;
        printf("%lld\n",max(z1,z2)*);
    }
}
/*
1
4 2
1400 700 2100 900
1 3
3 4
*/