zoj 3715 Kindergarden Election

Kindergarden Election

At the beginning of the semester in kindergarten, the n little kids (indexed from 1 to n, for convenience) in class need to elect their new leader.

The i^th kid will vote for his best friend f_i (where 1 ≤ f_i ≤ n, and it's too shame to vote for yourself, so f_i ≠ i). And the kid who gets the most votes will be the leader. If more than one kids who get the largest number of votes, there will be multiple leaders in the new semester.

Little Sheldon (the kid with index 1) is extremely vain, and he would like to be theONLY leader. (That means the number of votes he gets should strictly larger than any other.) Soon Sheldon found that if he give c_i candies to the i^th kid, the i^thkid would regard Sheldon as the new best friend, and of course vote for Sheldon.

Every kid including Sheldon loves candies. As an evil programmer, please help the evil Sheldon become the ONLY leader with minimum cost of candies. By the way, Sheldon should vote for any one he wants EXCEPT himself.

Input

There are multiple test cases. The first line of input contains an integer T (T ≤100) indicating the number of test cases. Then T test cases follow.

The first line of each case contains one integer: n (3 ≤ n ≤ 100) -- the number of kids in class.

The second line contains n-1 integers: f_i (1 ≤ f_i ≤ n, f_i ≠ i, and 2 ≤ i ≤ n) -- represents that the best friend of i^th kid is indexed with f_i.

The third line contains n-1 integers: c_i (1 ≤ c_i ≤ 1000, and 2 ≤ i ≤ n) -- represents that if Sheldon gave c_i candies to the i^th kid, the i^th kid would vote Sheldon, instead of their old best friend f_i, as the new semester leader.

Output

For each test case, print the minimal cost of candies to help Sheldon become theONLY leader.

Sample Input

2
4
1 1 2
1 10 100
3
3 2
1 10

Sample Output

0
11

Hint

In the first case,

• If Sheldon vote for 2^nd kid, the 2^nd kid and Sheldon will both have 2 votes. In this case, Sheldon have to pay 100 candies to the 4^th kid, and get 3 votes to win;
• If Sheldon vote for 3^rd or 4^th kid, Sheldon will win with 2 votes without sacrifice any candy.

题意：

这道题的题意是1号想要当班长，班长的票数一定要比其他的人都多！

但是每个人都有自己的朋友，并且会投自己的朋友一票，一号需要給不投自己的人一定的糖果才能够改投一号；

那么求出1号能成为班长的最小花费；

思路：

思路也是同学教的...orz；

假设x是现在一号所得的票数，那我们就枚举一号能够得到的各种票数，然后求所对应的最小花费，

所求即为最小花费中的最小值；具体我们贪心排序贿赂投i的人所需的糖果数（从小到大）；

*注意：贪心的做法是先砍掉票数>y-1的人的票数并贪心选择花费最小的，每枚举完一种票数会可能会出现三种               情况：（1）x+kan<y，那么就贪心选择那些点还可以再砍（还未被砍掉的点）；

                       （2）x+kan=y，得到最小花费；

                       （3）x+kan>y，不考虑了，因为向后枚举票数总会出现x+kan所对应的前两种情况；

代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<map>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
typedef long long ll;
typedef pair<int ,int> P;
const int inf=1e9-1;
const int maxn=110;

int c[maxn];    //花费；
int f[maxn];    //投给；
int cnt[maxn];  //得到的票数；
int used[maxn]; //是否已砍掉；
int n;

bool cmp(const int &a,const int &b)
{
    return c[a]<c[b];
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        vector<int>one,G[105];
        memset(cnt,0,sizeof(cnt));

        scanf("%d",&n);
        for(int i=2;i<=n;i++)
        {
            cin>>f[i];
            cnt[f[i]]++;
            if(f[i]!=1)
            {
                one.push_back(i);
                G[f[i]].push_back(i);
            }
        }

        for(int i=2;i<=n;i++)
            scanf("%d",&c[i]);
        sort(one.begin(),one.end(),cmp);
        for(int i=2;i<=n;i++)
            sort(G[i].begin(),G[i].end(),cmp);

        int ans=inf;
        for(int vote=2;vote<=n;vote++)
        {
            cnt[vote]++;
            for(int y=max(1,cnt[1]);y<n;y++) //枚举票数；
            {
                int d=y-cnt[1],w=0;
                mem(used,0);
                for(int i=2;i<=n;i++)  //贪心砍掉i的票数多于y-1的；
                {
                    if(cnt[i]<y) continue;
                    int t=cnt[i];
                    for(int j=0;j<G[i].size();j++)
                    {
                        d--;
                        t--;
                        w+=c[G[i][j]];
                        used[G[i][j]]=1;

                        if(d<=0||t<y)
                            break;
                    }
                    if(d<0||t>=y)
                    {
                        w=inf;
                        d=0;
                        break;
                    }
                }
                if(d>0)
                {
                    for(int i=0;d&&i<one.size();i++)
                    {
                        if(!used[one[i]])
                        {
                            w+=c[one[i]];
                            d--;
                        }
                    }
                }
                ans=min(ans,w);
            }
            cnt[vote]--;
        }
        cout<<ans<<endl;
    }
    return 0;
}