CF 808F Card Game 好题,最大点权独立集

 

题意:n张卡片,第i张卡片价值p[i],序号为c[i],等级为l[i],初始等级为1,不能选等级比自己大的物品.
现在从n张卡片中选出一个子集,要求其价值和不低于k,并且任意两个序号和不是素数.问最少要升到多少级.
n<=100,k<=1e5,p[i]<=1000,c[i]<=1e5,1<=l[i]<=n.


首先1<=l[i]<=n<=100.可以二分要升到的等级.
因为若c[a]+c[b]为prime,则(a,b)这两个不能同时选,选a就不能选b,选b就不能选a.有点独立集的感觉.
若c[a]为奇数,则源点向a连容量为p[a]的边.
对c[a]+c[b]为prime的点连接一条边 容量为inf (该边不可能在最小割上,(s,a),(b,t)至少有一条被选中)
若c[b]为偶数,则b向汇点连容量为p[b]的边.

 

 

则此时显然要求的就是该图的最大点权独立集 = 总权值-最小点权覆盖值(最小割).

 

 

#include<bits/stdc++.h>
using namespace std;
const int MAXN=300;
const int INF=0x3f3f3f3f;
struct edge{
    int from,to,cap,flow;
};
struct Dinic{
    int n,m,s,t;
    int vis[MAXN];
    int d[MAXN];
    int cur[MAXN];
    vector<int> G[MAXN];
    vector<edge> edges;
    void init(int n){
        this->n=n;
        for(int i=0;i<n;++i)G[i].clear();
        edges.clear();
    }
    void adde(int from,int to,int cap){
        edges.push_back(edge{from,to,cap,0});
        edges.push_back(edge{to,from,0,0});
        int m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool BFS(){
        memset(vis,0,sizeof(vis));
        vis[s]=1;
        d[s]=0;
        queue<int> q;
        q.push(s);
        while(!q.empty()){
            int x=q.front();
            q.pop();
            for(int i=0;i<G[x].size();++i){
                edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow){
                    d[e.to]=d[x]+1;
                    vis[e.to]=1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a){
        if(x==t||a==0)return a;
        int flow=0,f;
        for(int &i=cur[x];i<G[x].size();++i){
            edge& e=edges[G[x][i]];
            if(d[e.to]==d[x]+1&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
        return flow;
    }
    int Maxflow(int s,int t){
        this->s=s,this->t=t;
        int flow=0;
        while(BFS()){
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
}g;
const int MAXM=200010;
int n,k,p1,p2,pp1,pp2,vis[MAXM];
struct node{
    int p,c,l;
    void read(){
        scanf("%d%d%d",&p,&c,&l);
    }
    bool operator<(const node& r)const{
        return p>r.p;
    }
}odd[MAXN],even[MAXN],L[MAXN],R[MAXN];
vector<node> one;
void get_table(){
    int m=sqrt(MAXM+0.5);
    for(int i=2;i<=m;++i)if(!vis[i])
        for(int j=i*i;j<MAXM;j+=i)vis[j]=1;
}

bool check(int mid){
    int sum=0;
    pp1=pp2=0;
    for(int i=0;i<p1;++i)if(odd[i].l<=mid){
        sum+=odd[i].p;
        L[pp1++]=odd[i];
    }
    for(int i=0;i<p2;++i)if(even[i].l<=mid){
        sum+=even[i].p;
        R[pp2++]=even[i];
    }
    for(int i=0;i<one.size();++i)if(one[i].l<=mid){
        L[pp1++]=one[i];
        sum+=one[i].p;
        break;
    }
    int s=pp1+pp2,t=s+1;
    g.init(t+1);
    for(int i=0;i<pp1;++i)g.adde(s,i,L[i].p);
    for(int i=0;i<pp2;++i)g.adde(i+pp1,t,R[i].p);
    for(int i=0;i<pp1;++i)
        for(int j=0;j<pp2;++j){
            int v=L[i].c+R[j].c;
            if(!vis[v])g.adde(i,j+pp1,INF);
        }
    int ans=sum-g.Maxflow(s,t);
    return ans>=k;
}
int main(){
    get_table();
    scanf("%d%d",&n,&k);
    node t;
    p1=p2=pp1=pp2=0;
    int L=0,R=0;
    for(int i=0;i<n;++i)
	{
        t.read();
        R=max(R,t.l);
        if(t.c!=1&&(t.c&1))odd[p1++]=t;
        else if(t.c==1)one.push_back(t);
        else even[p2++]=t;
    }
    sort(one.begin(),one.end());
    if(!check(R))printf("-1\n");
    else{
        while(L<R){
            int mid=(L+R)>>1;
            if(check(mid))R=mid;
            else L=mid+1;
        }
        printf("%d\n",L);
    }
    return 0;
}