Gym - 100548C The Problem Needs 3D Arrays

Problem C.   The Problem Needs 3D Arrays

　　Time Limit: 6000MS Memory Limit: 262144KB 64bit IO Format: %I64d & %I64u

Description

A permutation is a sequence of integers p₁,p₂,...,p_n, consisting of n distinct positive integers and each of them does not exceed n. Assume that r(S) of sequence S denotes the number of inversions in sequence S (if i < j and S_i > S_j, then the pair of (i,j) is called an inversion of S), l(S) of sequence S denotes the length of sequence S. Given a permutation P of length n, it’s your task to find a subsequence S of P with maximum. A subsequence of P is a sequence (p_i1,p_i2,...,p_it) which satisfies that 0 < i₁ < i₂ < ... < i_t ≤ n.

Input

The first line of the input gives the number of test cases, T. T test cases follow.

For each test case, the first line contains an integer n (1 ≤ n ≤ 100), the length of the permutation P. The second line contains n integers p₁,p₂,...,p_n, which represents the permutation P.

Output

For each test case, output one line containing “Case #x: y”, where x is the test case number (starting from 1) and y is the maximum.

Your answer will be considered correct if it is within an absolute error of 10−⁶ of the correct answer.

Samples

Sample Input	Sample Output
1 5 3 4 2 5 1	Case #1: 1.250000000000

解题：最大密度子图转为最大权闭合图

 #include <bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 const int INF = 0x3f3f3f3f;
 int n,m,tot,S,T,x[maxn],y[maxn],A[];
 struct arc {
     int to,next;
     double flow;
     arc(int x = ,double y = ,int z = -) {
         to = x;
         flow = y;
         next = z;
     }
 } e[maxn<<];
 int head[maxn],cur[maxn],d[maxn];
 void add(int u,int v,double flow) {
     e[tot] = arc(v,flow,head[u]);
     head[u] = tot++;
     e[tot] = arc(u,,head[v]);
     head[v] = tot++;
 }
 queue<int>q;
 bool bfs() {
     memset(d,-,sizeof d);
     while(!q.empty()) q.pop();
     q.push(S);
     d[S] = ;
     while(!q.empty()) {
         int u = q.front();
         q.pop();
         for(int i = head[u]; ~i; i = e[i].next) {
             if(e[i].flow >  && d[e[i].to] == -) {
                 d[e[i].to] = d[u] + ;
                 q.push(e[i].to);
             }
         }
     }
     return d[T] > -;
 }
 double dfs(int u,double low) {
     if(u == T) return low;
     double tmp = ,a;
     for(int &i = cur[u]; ~i; i = e[i].next) {
         if(e[i].flow >  && d[e[i].to] == d[u] +  &&(a=dfs(e[i].to,min(e[i].flow,low)))>) {
             e[i].flow -= a;
             e[i^].flow += a;
             low -= a;
             tmp += a;
             if(low <= ) break;
         }
     }
     if(tmp <= ) d[u] = -;
     return tmp;
 }
 bool dinic() {
     double ans = m;
     while(bfs()) {
         memcpy(cur,head,sizeof head);
         ans -= dfs(S,INF);
     }
     return ans <= ;
 }
 void build(double delta) {
     memset(head,-,sizeof head);
     for(int i = tot = ; i < m; ++i) {
         add(S,i + n + ,1.0);
         add(i + n + ,x[i],INF);
         add(i + n + ,y[i],INF);
     }
     for(int i = ; i <= n; ++i) add(i,T,delta);
 }
 int main() {
     int cm = ,cs;
     scanf("%d",&cs);
     while(cs--) {
         scanf("%d",&n);
         m = ;
         for(int i = ; i <= n; ++i) {
             scanf("%d",A+i);
             for(int j = i-; j > ; --j)
                 if(A[j] > A[i]) {
                     x[m] = j;
                     y[m++] = i;
                 }
         }
         S = ;
         T = n + m + ;
         double low = ,high = m,ans = ;
         if(m == ) {printf("Case #%d: %.7f\n",cm++,ans);continue;}
         while(high - low > 1e-){
           double mid = (low + high)/2.0;
           build(mid);
           if(dinic()) ans = high = mid;
           else low = mid;
         }
         printf("Case #%d: %.7f\n",cm++,ans);
     }
     return ;
 }