HDU 4106 Fruit Ninja

这个考费用流建图（时间跑到HDU目前的第四）

是poj3680的加强版

poj 3680 是区间对点的限制，而这道题，是点对区间的限制。如果选取取一个数，那么每个包含这个数且长度为 M的连续区间内可以选的数都要减少一个，对吧？转换模型！点变区间，区间变点！把区间离散化为 n - m + 1个部分，那么就有 n - m + 2 个点，left = max(1,i-m+1) ；right = min(i,tot-1)+1;分别是每个点对区间限制的左边界和右边界。

#include<cstdio>
#include<stdlib.h>
#include<cstring>
using namespace std;
const int inf=99999999;
struct{
    int v, cap, cost, next, re;
}edge[10005];
int n,ans;
int k,edgeHead[1050];
int que[10050],pre[1050],dis[1050];
bool vis[1050];
int wei[1050];
int min(int a,int b){
    return a>b?b:a;
}
int max(int a,int b){
    return a>b?a:b;
}
void addEdge(int u,int v,int ca,int co){
    edge[k].v=v;
    edge[k].cap=ca;
    edge[k].cost=co;
    edge[k].next=edgeHead[u];
    edge[k].re=k + 1;               //这个用来记录此边的反边
    edgeHead[u]=k ++;
    edge[k].v=u;
    edge[k].cap=0;
    edge[k].cost=-co;               //故这里去反费用（因为是反向边）
    edge[k].next=edgeHead[v];
    edge[k].re=k - 1;
    edgeHead[v]=k ++;
}

bool spfa(){                //寻找最长增广路时如果是正向边则+相应的费用，反向边-相应的费用
    int i, head = 0, tail = 1;    //  长注释的地方就是从最小费用改到最大费用时需要变动的地方
    for(i = 0; i <= n; i ++){
        dis[i] = inf;
        vis[i] = false;
    }
    dis[0] = 0;
    que[0] = 0;
    vis[0] = true;
    while(head != tail){
        int u = que[head];
        for(i = edgeHead[u]; i != 0; i = edge[i].next){
            int v = edge[i].v;
            if(edge[i].cap && dis[v] >dis[u] + edge[i].cost){
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;                        // 这个pre数组记录的是从边号为i的那条边去往v
                if(!vis[v]){
                    vis[v] = true;
                    que[tail ++] = v;
                    if(tail == 10000) tail = 0;             // 这里用到了循环队列，节省空间
                }
            }
        }
        vis[u] = false;
        head++;
        if(head ==10000) head = 0;
    }
    if(dis[n] ==inf) return false;///
    return true;
}

void end(){
    int u, p;
    for(u = n; u != 0; u = edge[edge[p].re].v){
        p = pre[u];
        edge[p].cap -= 1;
        edge[edge[p].re].cap += 1;
        ans += edge[p].cost;
    }
}
int main(){
    int i,j,v,lim,m,sum;
    while(scanf("%d %d %d",&v,&m,&lim)!=EOF){
        k=1;
        sum=0;
        memset(edgeHead,0,sizeof(edgeHead));
        for(i=1;i<=v;i++){
            scanf("%d",&wei[i]);
            sum+=wei[i];
        }
        if(m<=lim){
            printf("%d\n",sum);
            continue;
        }                            //不加这个剪枝就TLE
        n=v-m+2;     //在v个点里面一共有v-m+1个长度为m的区间，现在把这v-m+1个数两两之间用点隔开，那么一共用v-m+2个点
        for(i=0;i<n;i++){
            addEdge(i,i+1,lim,0);
        }
        for(i=1;i<=v;i++){
            addEdge(max(1,i-m+1),min(n-1,i)+1,1,-wei[i]);   //如果选v这个点则从max(1,i-m+1)到min(n-1,i)+1的区间内每个点(此点代表的是线段)可选的点数就会减一
        }
        ans=0;
        while(spfa())
            end();
        printf("%d\n",-ans);
    }
    return 0;
}

 也可以这样建图：在每个点的前后个新建一个点，可以把闭区间问题转化为开区间问题

#include<cstdio>
#include<stdlib.h>
#include<cstring>
using namespace std;
const int inf=99999999;
struct{
    int v, cap, cost, next, re;
}edge[10005];
int n,ans;
int k,edgeHead[2050];
int que[10050],pre[2050],dis[2050];
bool vis[2050];
int wei[1050];
int min(int a,int b){
    return a>b?b:a;
}
int max(int a,int b){
    return a>b?a:b;
}
void addEdge(int u,int v,int ca,int co){
    edge[k].v=v;
    edge[k].cap=ca;
    edge[k].cost=co;
    edge[k].next=edgeHead[u];
    edge[k].re=k + 1;               //这个用来记录此边的反边
    edgeHead[u]=k ++;
    edge[k].v=u;
    edge[k].cap=0;
    edge[k].cost=-co;               //故这里去反费用（因为是反向边）
    edge[k].next=edgeHead[v];
    edge[k].re=k - 1;
    edgeHead[v]=k ++;
}

bool spfa(){                //寻找最长增广路时如果是正向边则+相应的费用，反向边-相应的费用
    int i, head = 0, tail = 1;    //  长注释的地方就是从最小费用改到最大费用时需要变动的地方
    for(i = 0; i <= n; i ++){
        dis[i] = inf;
        vis[i] = false;
    }
    dis[0] = 0;
    que[0] = 0;
    vis[0] = true;
    while(head != tail){
        int u = que[head];
        for(i = edgeHead[u]; i != 0; i = edge[i].next){
            int v = edge[i].v;
            if(edge[i].cap && dis[v] >dis[u] + edge[i].cost){
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;                        // 这个pre数组记录的是从边号为i的那条边去往v
                if(!vis[v]){
                    vis[v] = true;
                    que[tail ++] = v;
                    if(tail == 10000) tail = 0;             // 这里用到了循环队列，节省空间
                }
            }
        }
        vis[u] = false;
        head++;
        if(head ==10000) head = 0;
    }
    if(dis[n] ==inf) return false;///
    return true;
}

void end(){
    int u, p;
    for(u = n; u != 0; u = edge[edge[p].re].v){
        p = pre[u];
        edge[p].cap -= 1;
        edge[edge[p].re].cap += 1;
        ans += edge[p].cost;
    }
}
int main(){
    int i,j,v,lim,m,sum;
    while(scanf("%d %d %d",&v,&m,&lim)!=EOF){
        k=1;
        sum=0;
        memset(edgeHead,0,sizeof(edgeHead));
        for(i=1;i<=v;i++){
            scanf("%d",&wei[i]);
            sum+=wei[i];
        }
        if(m<=lim){
            printf("%d\n",sum);
            continue;
        }                            //不加这个剪枝就TLE
        n=v-m+1;
        for(i=0;i<=2*n+1;i++){
            addEdge(i,i+1,lim,0);
        }
        for(i=1;i<=v;i++){
            addEdge(2*max(1,i-m+1)-1,2*min(n,i)+1,1,-wei[i]);
        }
        ans=0;
        n=2*n+2;
        while(spfa())
            end();
        printf("%d\n",-ans);
    }
    return 0;
}