hdu 3998

统计不相交LIS个数

MAX FLOW

dinic...太慢了，SAP竟然0ms

 dp直接n2去做，记录每个元素结尾的LIS长度

建图的时候，dp[i]=1的与源点建图，dp[i]=LIS的与汇点建图，dp[i] == dp[j] + 1, i, j 建图

跑一边最大流

#include <bits/stdc++.h>

const int INF = 0x3f3f3f3f;
const int MAXN = 1e3+10;
const int MAXM = 1e6+10;

int a[MAXN];
int dp[MAXN];
int ans[MAXN];
int tot, head[MAXN];
int layer[MAXN];
int cur[MAXN];
int sta[MAXN];
int top;
int gap[MAXN];
int n, m;

struct Edge {
    int u, v, cap, next;
    Edge(){}
    Edge(int _u, int _v, int _cap, int _next)
    {
        u = _u;
        v = _v;
        cap = _cap;
        next = _next;
    }
} edge[MAXM];

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

void addEdge(int u, int v, int cap)
{
    edge[++tot] = Edge(u, v, cap, head[u]);
    head[u] = tot;
}

void bfs(int src,int sink)
{
    memset(layer, -1, sizeof(layer));
    memset(gap, 0, sizeof(gap));
    gap[0] = 1;
    int que[MAXN];
    int front,rear;
    front = rear = 0;
    layer[sink] = 0;
    que[rear++] = sink;
    while(front != rear)
    {
        int u = que[front++];
        if(front == MAXN)
            front = 0;
        for(int i = head[u]; i > 0; i = edge[i].next)
        {
            int v = edge[i].v;
            if(layer[v] != -1) 
                continue;
            que[rear++] = v;
            if(rear == MAXN)rear=0;
            layer[v] = layer[u]+1;
            ++gap[layer[v]];
        }
    }
}
int SAP(int src,int sink)
{
    int res = 0;
    top = 0;
    bfs(src,sink);
    memcpy(cur, head, sizeof(head));
    int u = src;
    int i;
    while(layer[src] < n) {
        if(u == sink) {
            int temp = INF;
            int inser;
            for (i = 0; i < top; ++i)
                if (temp > edge[sta[i]].cap) {
                    temp = edge[sta[i]].cap;
                    inser = i;
                }
            for (i = 0; i < top; ++i) {
                edge[sta[i]].cap -= temp;
                edge[sta[i]^1].cap += temp;
            }
            res += temp;
            top = inser;
            u = edge[sta[top]].u;
        }
        if (u != sink && gap[layer[u]-1] == 0)
            break;
        for (i = cur[u]; i > 0; i = edge[i].next)
            if (edge[i].cap > 0 && layer[u] == layer[edge[i].v] + 1)
                break;
        if(i > 0) {
            cur[u] = i;
            sta[top++] = i;
            u = edge[i].v;
        }
        else {
            int min = n;
            for (i = head[u]; i > 0; i = edge[i].next) {
                if (edge[i].cap == 0)
                    continue;
                if (min > layer[edge[i].v]) {
                    min = layer[edge[i].v];
                    cur[u] = i;
                }
            }
            --gap[layer[u]];
            layer[u] = min+1;
            ++gap[layer[u]];
            if(u != src)
                u = edge[sta[--top]].u;
        }
    }
    return res;
}


int getLIS()
{
    int len = 0;
    dp[1] = 1;
    for (int i = 2; i <= n; ++i) {
        dp[i] = 1;
        for (int j = i-1; j >= 1; --j) {
            if (a[i] > a[j]) {
                dp[i] = std::max(dp[i], dp[j] + 1);
            }
        }
        len = std::max(len, dp[i]);
        //printf("dp[%d] = %d
", i, dp[i]);
    }
    //printf("len = %d
", len);
    return len;
}


int main()
{
    while (~scanf("%d", &n)) {
        init();
        a[0] = -INF;
        for (int i = 1; i <= n; ++i)
            scanf("%d", a+i);
        int len = getLIS();

        int src = 0, sink = n+1;
        for (int i = 1; i <= n; ++i) {
            if (dp[i] == 1) {
                addEdge(src, i, 1);
                addEdge(i, src, 0);
            }
            if (dp[i] == len) {
                addEdge(i, sink, 1);
                addEdge(sink, i, 0);
            }
        }

        for (int i = 1; i <= n; ++i) {
            for (int j = i+1; j <= n; ++j) {
                if (dp[j] == dp[i] + 1) {
                    addEdge(i, j, 1);
                    addEdge(j, i, 0);
                }
            }
        }

        // run max_flow
        int res = SAP(src, sink);
        printf("%d
%d
", len, res);
    }
}