网络流24题——P2766

题目

PS 最近学习网络流真的是头大了，学了几天仍然只会用套Dinic做一些简单的最大流，二分图匹配等问题，感觉网络流的关键是30%的板子水平（必须得深入理解，且易修改）+70%的建模建图水平，等做到那种万物皆可网络流就差不多出师了
看了太多神仙建模之后的我做线代高数都想用网络流了，我也太菜了吧Ծ‸Ծ

«问题描述：
给定正整数序列x1,…,xn 。
（1）计算其最长不下降子序列的长度s。
（2）计算从给定的序列中最多可取出多少个长度为s的不下降子序列。
（3）如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长度为s的不下降子序列。
«编程任务：
设计有效算法完成（1）（2）（3）提出的计算任务。

链接在这里：洛谷P2766

题解

这道属于简单的建图

1. 先用floyed算法预处理，得到第一题答案，用F[i] 表示如果将第i个数作为序列的最后一位，那最多能有多长，将每一个点拆成两个点，入点和出点，容量为1（网络流基操），保证每一个数只被选一次
2. 再将F[i] =1的点的入点与源点用inf容量边连接，最后将F[i] =n的点的出点与汇点也用inf容量边连接，跑一边Dinic，得到第二个解
3. 第三题只需要将第一个和最后一个点的入点与出点之间点的边容量改为inf就行了

话说洛谷也太好用了吧，要是没有提供的数据，我估计要死在这一题上了

#include<bits/stdc++.h>
using namespace std;
const int maxm=2000;
const int MAX_V = 2000;
const int INF =0x3f3f3f3f;
int a[MAX_V],F[MAX_V],b[MAX_V];
struct edge
{
    int to, cap;
    unsigned int rev;
};
vector<edge> G[maxm],g[maxm];
int level[MAX_V], iter[MAX_V];
void add_edge(int from, int to, int cap)
{
    G[from].push_back({ to, cap, G[to].size()});
    G[to].push_back({from, 0, G[from].size() - 1});
}
int bfs(int s,int t)
{
    memset(level,0,sizeof(level));
    level[s]=1;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();q.pop();
        if(x==t) return 1;
        for(unsigned int i=0;i<G[x].size();i++)
        {
            int v=G[x][i].to,f=G[x][i].cap;
            if(!level[v]&&f)
            {
                level[v]=level[x]+1;
                q.push(v);
            }
        }
    }
    return 0;
}

int dfs(int s,int t,int maxf)
{
    if(s==t) return maxf;
    int ret=0;
    for(unsigned int i=0;i<G[s].size();i++)
    {
        int v=G[s][i].to,f=G[s][i].cap;
        if(level[s]+1==level[v]&&f)
        {
            int minn=min(maxf-ret,f);
            edge &u=G[s][i];
            f=dfs(v,t,minn);
            G[s][i].cap-=f;
            G[u.to][u.rev].cap+=f;
            ret+=f;
            if(ret==maxf) return ret;
        }
    }
    return ret;
}
int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t)) ans+=dfs(s,t,INF);
    return ans;
}
void initial(int N)
{
	for(int i=0;i<=N;i++)
	{
		G[i].clear();
	}
}
void search(int n,int N)
{
	for(int i=n+1;i<=n+N;i++)
	{
		cout<<i-n<<":";
		for(int j=1;j<G[i].size();j++)
		{
			if(G[i][j].cap)
			{
				cout<<G[i][j].to<<' ';
			}
		}
		cout<<endl;
	}
}
int lis(int N)
{
	int max1,ans1=0;
	for(int i=1;i<=N;i++)
	{
		max1=1;
		for(int j=1;j<i;j++)
		{
			if(a[i]>=a[j])
			{
				max1=max(max1,F[j]+1);
			}
		}
		F[i]=max1;
		ans1=max(ans1,max1);
	}
	return ans1;
}
void chushi(int N,int ans1)
{
	for(int i=1;i<=N;i++)
	{
		add_edge(i,i+N,1);
		if(F[i]==1)
		{
			add_edge(0,i,INF);
			continue;
		}
		if(F[i]==ans1)
		{
			add_edge(i+N,2*N+1,INF);
		}
		for(int j=1;j<=i-1;j++)
		{
			if(a[j]<=a[i]&&F[j]+1==F[i])
			{
				add_edge(j+N,i,1);
			}
		}
	}
}
int main()
{
	int n,N,m,x1,x2,ans1,ans2,ans3;
	cin>>N;
	for(int i=1;i<=N;i++)
	{
		scanf("%d",&a[i]);
	}
	ans1=lis(N);
	/*for(int i=1;i<=N;i++)
	{
		cout<<"  "<<F[i]<<' ';
	}
	cout<<endl;*/
	cout<<ans1<<endl;
	if(ans1==1)
	{
		cout<<N<<endl;
		cout<<N<<endl;
		return 0;
	}
	chushi(N,ans1);
	for(int i=0;i<=2*N+1;i++)
	{
		g[i]=G[i];
	}
	ans2=dinic(0,2*N+1);
	cout<<ans2<<endl;
	for(int i=0;i<=2*N+1;i++)
	{
		G[i]=g[i];
	}
	G[1][0].cap=INF;
	G[N][0].cap=INF;
	ans3=dinic(0,2*N+1);
	cout<<ans3<<endl;
}