贪心—Ⅱ

• 国王游戏（贪心，高精度,微扰）

原题链接

按照每个大臣左，右手上的数的乘积从小到大排序，就是最优排队方案。

邻项交换证明：

最后根据冒泡排序知识，任何一个序列都能通过邻项交换的方式变为有序序列。故当逆序对数为0，即按上述方案排序时就是最优策略

#include <iostream>
#include <algorithm>

using namespace std;

const int N=1e3+10;
typedef pair<int,int>PII;

PII p[N];

int n;

vector<int> mul(vector<int>a ,int b)
{
    vector<int>c;
    int t=0;
    for(int i=0;i<a.size()||t;i++)
    {
        if(i<a.size())t+=a[i]*b;
        c.push_back(t%10);
        t/=10;
    }
    //去一下前导零
    while(c.size()>1&&c.back()==0)c.pop_back();
    
    return c;
}

vector<int> div(vector<int> a,int b)
{
    int r=0;
    vector<int>c;
    for(int i=a.size()-1;i>=0;i--)
    {
        r=r*10+a[i];
        c.push_back(r/b);
        r=r%b;
    }
    reverse(c.begin(),c.end());
    while(c.size()>1&&c.back()==0)c.pop_back();
    
    return c;
    
}

vector<int> max_vec(vector<int>a,vector<int>b)
{
    if(a.size()>b.size())return a;
    if(a.size()<b.size())return b;
    if(vector<int>(a.rbegin(),a.rend())>vector<int>(b.rbegin(),b.rend()))   return a;
    return b;
}

int main()
{
    scanf("%d",&n);
    
    for(int i=0;i<=n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        p[i]={a*b,a};
    }
    
    sort(p+1,p+n+1);
    
    vector<int>product(1,1);//前面所有数的乘积，1初始化
    vector<int>res(1,0);//res，0初始化
    
    for(int i=0;i<=n;i++)
    {
        if(i)//国王不会给自己发奖励
            res=max_vec(res,div(product,p[i].first/p[i].second));
        product=mul(product,p[i].second);//乘积和
    }
    for(int i=res.size()-1;i>=0;i--)    cout<<res[i];
    cout<<endl;
    return 0;
}

• 给树染色（贪心+树上操作+并查集思想）

原题链接

是要权值valval最大的点x,越先被染色越好,这是正确的贪心.那么我们怎么染色呢?如果说我们要让x点染色的话,那么肯定它的父亲father[x]必须先被染色.既然如此的话,那么我们接着可以这样思考.
我们现在面临两个分支,如上图中的根节点1,到底选择2分支,还是3分治的时候.我们发现自然是选择2好,但是计算机不知道,那么如何让计算机知道了,我们可以设置一个数组w,设w[x]表示为x为根节点的树的平均权值,也就是:

w[x]=x子树的权值总和/x子树的个数

#include <iostream>
#include <algorithm>

using namespace std;

const int N=1e3+10;

struct node
{
    int father,size,sum;
    double avg;
}nodes[N];

int n,root;

int find()
{
    int res=-1;
    double avg=0;
    for(int i=1;i<=n;i++)
    {
        if(i!=root&&avg<nodes[i].avg)//根节点没有父节点，不能往上合并
        {
            avg=nodes[i].avg;
            res=i;
        }
    }
    return res;
}

int main()
{
    int res=0;
    cin>>n>>root;
    for(int i=1;i<=n;i++)
    {
        auto &nd=nodes[i];
        scanf("%d",&nd.sum);
        nd.size=1;
        nd.avg=nd.sum;
        res+=nd.sum;
    }
    for(int i=0,a,b;i<n-1;i++)
    {
        scanf("%d%d",&a,&b);
        //a是b的父节点
        nodes[b].father=a;
    }
    //一共执行n-1次，把n个点合并成一个点
    
    for(int i=0;i<n-1;i++)
    {
        //当前所有节点里权值最大的非根节点
        int var=find();
        //其父节点
        int f=nodes[var].father;
        
        //当前节点的权值乘上父节点的节点个数
        res+=nodes[var].sum*nodes[f].size;
        
        //把这个点删掉，特殊赋值-1，让其在找最大值时不存在
        nodes[var].avg=-1;
        
        //合并
        for(int j=1;j<=n;j++)
        {
            if(nodes[j].father==var)
            {
                nodes[j].father=f;
                
            }
        }
        //更新父节点信息
        nodes[f].sum+=nodes[var].sum;
        nodes[f].size+=nodes[var].size;
        nodes[f].avg=(double)nodes[f].sum/nodes[f].size;
    }
    
    cout<<res<<endl;
    
    return 0;
}