洛谷 P2766 最长不下降子序列问题 dp 最大流

洛谷 p2766

题目呢很裸的三个要求
1）求出最长不下降子序列长度s
2）求出最多有多少个长度为s的不下降子序列
3）如果1和xn可以无限使用，又有多少个长度为s的不下降子序列

那么我们侧重于三个问题来分析如何解题， 首先第一题我们很容易发现是LIS问题，直接dp求解，后两个问我们可以考虑一下2网络流的解法，对于这样一道题建图的时候我们考虑一下如何建图， 既然要跑网络流，那么我们的思路又是什么呢？我们的最大流是长度为s的子序列个数，那么我们这样考虑，我们把子序列的众多于T相连接， 起点与S相连接，这样我们就很容易的得到了子序列的个数，那么中间点的关系我们如何建立呢？其实很简单我们只需要把相邻的点建立关系就OK了，说道这我们有一个问题没有考虑到，那么就是每一个点只能用一次，这个问题其实我们也很容易解决，按照套路进行拆点就OK了啊，那么我们该如何确定起点和终点呢？这就回归到第一问dp求解了，我们在dp数组中存储以改点为终点的最长子序列长度，这样dp【i】== 1则为起点dp【i】 == s则为终点

AC 代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<vector>

using namespace std;

const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int next, to, w;
}edg[MAXN];

int head[MAXN], dep[MAXN], cnt = 0;

void init()
{
    memset(head, -1, sizeof(head));
    cnt = 0;
}

inline void Add_edge(int u, int v, int w)
{
    edg[cnt].w = w;
    edg[cnt].to = v;
    edg[cnt].next = head[u];
    head[u] = cnt++;
    edg[cnt].to = u;
    edg[cnt].w = 0;
    edg[cnt].next = head[v];
    head[v] = cnt++;
}

bool BFS(int s, int t)
{
    queue<int> q;
    while(!q.empty()) q.pop();
    memset(dep, 0, sizeof(dep));
    dep[s] = 1;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        for(int i = head[u]; i != -1; i = edg[i].next)
        {
            int v = edg[i].to;
            int w = edg[i].w;
            if(w && dep[v] == 0)
            {
                dep[v] = dep[u] + 1;
                q.push(v);
                if(v == t)
                    return true;
            }
        }
    }
    return false;
}

int DFS(int s, int mw, int t)
{
    if(s == t)
        return mw;
    int res = 0, k;
    for(int i = head[s]; i != -1 && res < mw; i = edg[i].next)
    {
        int v = edg[i].to;
        int w = edg[i].w;
        if(w && dep[v] == dep[s] + 1)
        {
            k = DFS(v, min(mw - res, edg[i].w), t);
            if(k == 0)
                dep[v] = 0;
            edg[i].w -= k;
            edg[i^1].w += k;
            res += k;
        }
    }
    return res;
}

int Dinic(int s, int t)
{
    int maxflow = 0;
    while(BFS(s, t))
    {
        while(int d = DFS(s, INF, t))
        {
            maxflow += d;
        }
    }
    return maxflow;
}


int main()
{
    int dp[MAXN], num[MAXN];
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d", &num[i]);
        dp[i] = 1;
    }
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j < i; ++j)
        {
            if(num[j] <= num[i])
                dp[i] = max(dp[i], dp[j] + 1);
        }
    }
    int len = -1;
    for(int i = 1; i <= n; ++i)
        len = max(len, dp[i]);
        printf("%d\n", len);
    int s = 0, t = 5000;
    init();
    for(int i = 1; i <= n; ++i)
    {
        if(dp[i] == 1)
            Add_edge(s, i, 1);
    }
    for(int i = 1; i <= n; ++i)
    {
        if(dp[i] == len)
            Add_edge(i + n, t, 1);
    }
    for(int i = 1; i <= n; ++i)
            Add_edge(i, i + n, 1);
    for(int i = 1; i <=  n; ++i)
    {
        for(int j = 1; j < i; ++j)
        {
            if(dp[j] + 1 == dp[i] && num[j] <= num[i])
                Add_edge(j + n, i, 1);
        }
    }
     int maxflow = 0;
    while(BFS(s, t))
    {
        while(int d = DFS(s, INF, t))
        {
            maxflow += d;
        }
    }
    printf("%d\n", maxflow);
    Add_edge(1, n + 1, INF); Add_edge(s, 1, INF);
    if(dp[n] == len)
        Add_edge(n, n * 2, INF), Add_edge(n * 2, t, INF);
         //int maxflow = 0;
    while(BFS(s, t))
    {
        while(int d = DFS(s, INF, t))
        {
            maxflow += d;
        }
    }
    printf("%d\n", maxflow);
}