C++博客-小阮的菜田-随笔分类-USACO

USACO_MAR11 Spiral (螺旋矩阵, 模拟)

小阮 — Fri, 11 Mar 2011 15:21:00 GMT

模拟

/*
ID: lorelei
TASK: spiral
LANG: C++
*/

#include <fstream>

using namespace std;

const int MAXN  = 800;
const int dx[]= {0,1,0,-1};
const int dy[]= {1,0,-1,0};

ifstream fin("spiral.in");
ofstream fout("spiral.out");

int m[MAXN][MAXN];
int N,M;

int main(){
    int i, j, x=1, y=1, dir=0;
    fin>>N;
    M = N*N;

    for(i=1; i<=M; ++i){
        m[x][y]=i;

        int tx = x + dx[dir];
        int ty = y + dy[dir];

        if(m[tx][ty] || tx>N || ty>N || tx<1 || ty<1){
            dir++;
            if(dir==4)dir=0;
        }

        x += dx[dir];
        y += dy[dir];
    }

    for(i=1; i<=N; ++i){
        for(j=1; j<N; ++j)
            fout<<m[i][j]<<" ";
        fout<<m[i][N]<<endl;
    }
    return 0;
}

小阮 2011-03-11 23:21 发表评论

USACO 6.1.2 A Rectangular Barn (最大子矩阵, DP)

小阮 — Fri, 18 Feb 2011 07:43:00 GMT

题意：求最大子矩阵。

设h[i,j]是点(i, j)向上的最长距离，l[i,j]是点(i, j)向左的最长距离，r[i,j]是点(i, j) 向右的最常距离，

点(i, j)处的矩形面积＝ h[i, j]*(l[i, j]+r[i, j]-1)

h[i, j] = h[i-1,j]+1 （点(i, j)是好的）
h[i, j] = 0              （点(i, j)是坏的）

l[i, j] = min( l[i-1, j] , k) （点(i, j)是好的）
l[i, j] = 0                       （点(i, j)是坏的）

r[i, j] = min(l[i-1, j], k) （点(i, j)是好的）
r[i, j] = 0                     （点(i, j)是坏的）

/*
ID: lorelei3
TASK: rectbarn
LANG: C++
*/

#include <fstream>

using namespace std;

const int MAX = 3005;

ifstream fin("rectbarn.in");
ofstream fout("rectbarn.out");

bool map[MAX][MAX];
int h[MAX], l[MAX], r[MAX];
int R,C,P,ans;

void input(){
    int x,y;
    fin>>R>>C>>P;
    for(int i=0; i<P; ++i){
        fin>>x>>y;
        map[x][y]=true;
    }
}

inline int min(int a, int b){
    if (a<b && a!=0)
        return a;
    return b;
}

inline int max(int a, int b){
    return a>b?a:b;
}
void dp(){
    int i,j,k;
    for(i=1; i<=R; ++i){
        k=0;
        for(j=1; j<=C; ++j){
            if(!map[i][j]){
                h[j]=h[j]+1;
                l[j]=min(l[j], ++k);
            }else
                h[j]=0, l[j]=0, k=0;
        }

        k=0;
        for(j=C; j>=1; --j){
            if(!map[i][j]){
                r[j]=min(r[j], ++k);
                ans=max(ans, h[j]*(l[j]+r[j]-1));
            }else
                r[j]=0, k=0;
        }
    }
}

void output(){
    fout<<ans<<endl;
}

int main(){

    input();

    dp();

    output();

    return 0;
}

小阮 2011-02-18 15:43 发表评论

USACO 6.1.1 Postal Vans (哈密顿回路, 递推, 高精度计算)

小阮 — Fri, 18 Feb 2011 03:58:00 GMT

摘要: 题意是求哈密顿回路的多少，可以用《基于连通性状态压缩的动态规划问题》来解，但由于只有4行，所以可以发现一些规律，其他人写的比较多了，就不列举出来，设f[i] 表示前i列中，第i列的第一个格子到第二个格子的哈密顿路的条数。本题的答案自然就是f[n]。设g[i]表示前i列中，第i列的第一个格子到第四个格子的哈密顿路的条数。f[i]的递推关系： f[i] = f[i-1] + g[i-1]g[i]的递推... 阅读全文

小阮 2011-02-18 11:58 发表评论

USACO 5.5.3 Two Five (DP)

小阮 — Fri, 18 Feb 2011 03:50:00 GMT

等待补充

小阮 2011-02-18 11:50 发表评论

USACO 5.5.2 Hidden Passwords (后缀数组)

小阮 — Thu, 17 Feb 2011 09:10:00 GMT

摘要: 后缀数组的简单应用。 /**//*ID: lorelei3TASK: hiddenLANG: C++*/#include #include #include using namespace std;const in... 阅读全文

小阮 2011-02-17 17:10 发表评论

USACO 5.5.1 Picture (离散化)

小阮 — Thu, 17 Feb 2011 05:56:00 GMT

将每个矩形拆分为2条横边和2条纵边，用一个结构体记录，

以横边为例，记录开始的横坐标s，结束的横坐标e，该横边的纵坐标p，若该横边是一个矩形下边的边，则start为ture，若是一个矩形上边的边，则为false，

记录后按纵坐标从小到大排序，若纵坐标相等的，start为ture的优先。

(PS：STL的sort中，对于比较函数，若两个元素相等，则必需返回false，否则会导致sort死循环）

排序后，从小到大进行扫描。

使用level作为记录数组，

对于start = true 的横边，对于j = [s, e) ，进行level[j] ++ 若level[j]==1， ans++；
对于start = false的横边，对于j = [s, e)，进行level[j] -- 若level[j]==0， ans++；

（画个简图领会下）

纵边如此类推。

/*
ID: lorelei3
TASK: picture
LANG: C++
*/

#include <fstream>
#include <algorithm>
#include <memory.h>

using namespace std;

const int MAX = 20005;

struct Line{
    int s,e,p;
    bool start;

    bool operator < ( const Line &l) const{

        if(p==l.p){
            if(l.start == start)
                return false;

            if(start)
                return 1;
            else
                return 0;
        }
        return p<l.p?1:0;
    }
};

ifstream fin("picture.in");
ofstream fout("picture.out");

Line lx[MAX], ly[MAX];
long ans;

int n,m;
void input(){
    fin>>n;
    int x1,x2,y1,y2,lenx=0,leny=0;
    m=n+n;
    for(int i=0; i<=n; ++i){
        fin>>x1>>y1>>x2>>y2;
        lx[lenx].s=x1, lx[lenx].e=x2, lx[lenx].p=y1;
        lx[lenx].start=true;
        lenx++;

        lx[lenx].s=x1, lx[lenx].e=x2, lx[lenx].p=y2;
        lx[lenx].start=false;
        lenx++;

        ly[leny].s=y1, ly[leny].e=y2, ly[leny].p=x1;
        ly[leny].start=true;
        leny++;

        ly[leny].s=y1, ly[leny].e=y2, ly[leny].p=x2;
        ly[leny].start=false;
        leny++;
    }
    qsort(lx, m, sizeof(Line), cmp);
    qsort(ly, m, sizeof(Line), cmp);
    sort(lx, lx+m);
    sort(ly, ly+m);
}

int level[20005], zero=10000;
void solve(Line *l){

    memset(level, 0, sizeof(level));

    for(int i=0; i<m; ++i){
        if(l[i].start){
            for(int k=zero+l[i].s; k<(zero+l[i].e); ++k){
                level[k]++;
                if(level[k]==1)
                    ans++;
            }
        }else{
            for(int k=zero+l[i].s; k<(zero+l[i].e); ++k){
                level[k]--;
                if(level[k]==0)
                    ans++;
            }
        }
    }
}

void output(){
    fout<<ans<<endl;
}

int main(){
    input();
    solve(lx);
    solve(ly);
    output();
    return 0;
}

小阮 2011-02-17 13:56 发表评论

USACO 5.4.5 TeleCowmunication (最小点割集, Dinic)

小阮 — Thu, 17 Feb 2011 05:47:00 GMT

摘要: 本题是求最大点割集。首先，构造图。对于点i，分成u和v两点，并且dist[u][v]=1，dist[v][u]＝0；对于边(i, j)，对于i，根据上述方法分成a1，a2两点，j分成b1，b2；使dist[b1][a2]=INF，dist[a2][b1]=0； dist[b2][a1]=INF，dist[a1][b2]=0；然后根据最大流最小割定理，求最大流，使用Dinic。Dinic的原理是... 阅读全文

小阮 2011-02-17 13:47 发表评论

USACO 5.4.4 Betsy's Tour (DFS+剪枝)

小阮 — Wed, 16 Feb 2011 07:28:00 GMT

优化1：黑书P184, 一条完整的路径对于中间各点(除起点和目标点外)，必需包含一进一出，所以中间点必需至少有两个未经过的相邻点（除非当前点在旁边）

优化2：预防形成孤零区域。

/*
ID: lorelei3
TASK: betsy
LANG: C++
*/

#include <fstream>

using namespace std;

const int dx[]={1,0,-1,0};
const int dy[]={0,1,0,-1};
const int MAXN = 10;

ifstream fin("betsy.in");
ofstream fout("betsy.out");

bool map[MAXN][MAXN];

int n,ans,num;
void input(){
    fin>>n;
    for(int i=0; i<=n+1; ++i){
        map[0][i]=true, map[i][0]=true, map[n+1][i]=true, map[i][n+1]=true;
    }
    num=n*n;
}

inline int get(int x, int y){
    int cnt=0;
    for(int i=0; i<4; ++i)
        if(!map[x+dx[i]][y+dy[i]])
            cnt++;
    return cnt;
}

void dfs(int x, int y, int t){
    if(x==n&&y==1){
        if(t==num)
            ans++;
        return;
    }

    //优化2
    if(map[x][y-1]&&map[x][y+1]&&!map[x+1][y]&&!map[x-1][y] ||
        !map[x][y-1]&&!map[x][y+1]&&map[x+1][y]&&map[x-1][y] )
        return;

    //优化1
    int i,xi,yi,count=0;
    for(i=0; i<4; ++i){
        int tx=x+dx[i];
        int ty=y+dy[i];
        if(map[tx][ty] || (tx==n&&ty==1))
            continue;
        int p = get(tx,ty);
        if(p<=1){
            count++;
            xi=tx, yi=ty;
        }
    }

    if(count>1)
        return;
    else{
        if(count==1){
            map[xi][yi]=true;
            dfs(xi,yi,t+1);
            map[xi][yi]=false;
        }else{
            for(i=0; i<4; ++i){
                int tx=x+dx[i];
                int ty=y+dy[i];
                if(!map[tx][ty]){
                    map[tx][ty]=true;
                    dfs(tx,ty,t+1);
                    map[tx][ty]=false;
                }
            }
        }
    }
}

void solve(){
    map[1][1]=true;
    dfs(1,1,1);
}

void output(){
    fout<<ans<<endl;
}

int main(){

    input();

    solve();

    output();

    return 0;
}

小阮 2011-02-16 15:28 发表评论

USACO 5.4.3 Character Recognition (DP)

小阮 — Wed, 16 Feb 2011 07:23:00 GMT

动态规划

小阮 2011-02-16 15:23 发表评论

USACO 5.4.2 Canada Tour (DP)

小阮 — Mon, 14 Feb 2011 14:49:00 GMT

可以看成甲乙两个人同时从A点出发，经过不同的路径，到达B点的最长路径和。

设f[i,j]为甲走到第i座城市，乙走到第j座城市，路径的总和。

初始状态：f[1][1]=1；

转移方程：f[j, i ] = f[i,j] = max{f[i,k]+1} j,k间有路，1<=k
结果：ans = max{f[i,n]} i,n之有路

/*
ID: lorelei
TASK: tour
LANG: C++
*/

#include <fstream>
#include <string>

using namespace std;

const int MAX = 105;
const int INF = 0x7FFFFFF;

ifstream fin("tour.in");
ofstream fout("tour.out");

string city[105];
bool adj[MAX][MAX];
int n,v,ans;

inline int find(string str){
    for(int i=1; i<=n; ++i)
        if(str==city[i])
            return i;
}

void input(){
    int i;
    fin>>n>>v;
    for(i=1; i<=n; ++i)
        fin>>city[i];

    string s,t;
    for(i=1; i<=v; ++i){
        fin>>s>>t;
        int v1 = find(s);
        int v2 = find(t);
        adj[v1][v2]=adj[v2][v1]=true;
    }
}

int f[MAX][MAX];
void solve(){
    f[1][1]=1;
    for(int i=1; i<=n; ++i)
        for(int j=i+1; j<=n; ++j){
            f[i][j]=-INF;
            for(int k=1; k<j; ++k){
                if(adj[k][j] && f[i][k]>0 && f[i][k]>f[i][j])
                    f[i][j]=f[i][k];
            }
            f[j][i]= ++f[i][j];
        }
}

void output(){
    ans=1;
    for(int i=1; i<n; ++i)
        if(adj[i][n] && f[i][n]>ans)
            ans=f[i][n];
    fout<<ans<<endl;
}

int main(){

    input();

    solve();

    output();

    return 0;
}

小阮 2011-02-14 22:49 发表评论

USACO 5.4.1 All Latin Squares (拉丁方, DFS + 置换群剪枝)

小阮 — Mon, 14 Feb 2011 07:09:00 GMT

预备知识：

对于一个n*n的拉丁方总数为N(k)。

当第一行为 1，2，……，n；第一列为1，2，……，n时，拉丁方数为L(K)

存在如下公式：

N(K) = L(K) * N! * (N-1)!

说明：当L(k)确定后，第2到第你行的排列组成复合题意的拉丁方，所以乘以(n-1)!，第一到第N列的排列又是拉丁方，所以乘以 n!.

言归正传，本题是第一行固定为1，2，……，n，第一列为1，2，……，n。所以求得L(K)乘以(n-1)!即可。

优化一：

置换群(by Maigo). 以5为例，

1 2 3 4 5
2 1 4 5 3 置换圈(1,2) , (3,4,5) 最长长度为3

和

1 2 3 4 5
2 3 1 5 4 置换圈(4,5), (1,2,3) 最长长度为3

他们是等价的，只是数字先后顺序有变化，他们产生的结果是一致（要多多思考）。

参考 cmykrgb1 ，利用最长长度作为索引进行hash，即枚举到第二行最后一列后，计算置换圈的最长长度，若已计算出这个长度的拉丁方总数，则返回该长度的所有可能数。

优化二：都可以想到，枚举到第n-1行即可，直接ans++。

/*
ID: lorelei3
TASK: latin
LANG: C++
*/

#include <fstream>
#include <memory.h>

using namespace std;

const int fact[] = {1,1,2,6,24,120,720};
const int MAXN = 10;

ifstream fin("latin.in");
ofstream fout("latin.out");

int n, id, cnt[MAXN], a[MAXN];
long long ans;
bool row[MAXN][MAXN], col[MAXN][MAXN], v[MAXN];

void find(){
    id=2;
    int l,t;
    memset(v, false, sizeof(v));
    for(int i=1; i<=n; ++i)
        if(!v[i]){
            t=i; l=0;
            do{
                v[t]=true;
                t = a[t];
                l++;
            }while(!v[t]);
            if(l>id)
                id=l;
        }
}

void dfs(int x, int y){

    for(int i=1; i<=n; ++i)
        if(row[x][i] && col[y][i]){
            if(x==2){
                a[y]=i;
                if(y==n){
                    find();
                    if(cnt[id]>0){
                        ans += cnt[id];
                        return;
                    }
                }
            }
            row[x][i]=false;
            col[y][i]=false;
            if(y==n){
                if(x==n-1){
                    cnt[id]++;
                    ans++;
                }else
                    dfs(x+1, 2);
            }else
                dfs(x, y+1);
            row[x][i]=true;
            col[y][i]=true;
        }
}

int main(){
    fin>>n;

    if(n==2)
        ans=1;
    else{
        int i;
        memset(row, true, sizeof(row));
        memset(col, true, sizeof(col));
        memset(cnt, 0, sizeof(cnt));
        for(i=2; i<n; ++i) row[i][i]=false;
        for(i=1; i<=n; ++i) col[i][i]=false;
        ans=0;
        a[1]=2;
        dfs(2,2);
        ans *= fact[n-1];
    }

    fout<<ans<<endl;

    return 0;
}

小阮 2011-02-14 15:09 发表评论

USACO 5.3.4 Big Barn (DP)

小阮 — Fri, 11 Feb 2011 13:56:00 GMT

比较简单的DP。和3.3的Home on the Range差不多. 还简单些。

初始状态
f(i,n) = 1， (i,n)没树；f(i,n)=0，(i,n)有树。
f(n,i) = 1， (i,n)没树；f(i,n)=0，(i,n)有树。

状态转移方程：
i->n-1...1
j->n-1...1
若(i,j)没树
f[i,j] = min3(f[i+1][j], f[i][j+1], f[i+1][j+1])+1

记录最大的f[i,j]即可。

/*
ID: lorelei3
TASK: bigbrn
LANG: C++
*/

#include <fstream>

using namespace std;

const int MAXN = 1005;

ifstream fin("bigbrn.in");
ofstream fout("bigbrn.out");

int f[MAXN][MAXN];

inline int min3(int a, int b, int c){
    int t=a<b?a:b;
    return c<t?c:t;
}

int main(){
    int i,j,n, t, ans=1;

    fin>>n>>t;

    for(i=1; i<=n; ++i)
        for(j=1; j<=n; ++j)
            f[i][j]=-1;

    for(i=0; i<t; ++i){
        int a,b;
        fin>>a>>b;
        f[a][b]=0;
    }

    for(i=1; i<=n; ++i){
        if(f[i][n]!=0)
            f[i][n]=1;
        if(f[n][i]!=0)
            f[n][i]=1;
    }

    for(i=n-1; i>=1; --i)
        for(j=n-1; j>=1; --j)
            if(f[i][j]!=0){
                f[i][j]=min3(f[i+1][j], f[i][j+1], f[i+1][j+1])+1;
                if(f[i][j]>ans)
                    ans=f[i][j];
            }

    fout<<ans<<endl;

    return 0;
}

小阮 2011-02-11 21:56 发表评论

USACO 5.3.3 Network of Schools (最小基点, 强连通, kosaraju)

小阮 — Fri, 11 Feb 2011 11:40:00 GMT

第一问是求最小基点，采用两点DFS的kosaraju算法，对每个点进行DFS，标记visited为true，然后对反图再进行DFS，能遍历到的点属于一个强连通分量。（强连通分量上的边，求反之后，是仍然可以遍历到的，反图其实是过滤了非强连通的边）

然后把强连通分量收缩成一个点，构造新图。新图中，入度为0的点的个数就是最小基点。

第二问，若一个顶点入度为0或者出度为0的时候，该图一定不是强连通的。为了使添加的边最少，则应该把入度为0顶点和出度为0的顶点每个顶点添加1条边，使图中不存在入度为0顶点和出度为0的顶点。新图中，入度为0的点的个数为s1，出度为0的点的个数s2，求max(s1,s2)。

/*
ID: lorelei3
TASK: schlnet
LANG: C++
*/

#include <fstream>
#include <memory.h>

using namespace std;

const int MAXN = 105;

ifstream fin("schlnet.in");
ofstream fout("schlnet.out");

int adj[MAXN][MAXN], fadj[MAXN][MAXN], dist[MAXN][MAXN];
int belong[MAXN], ind[MAXN], outd[MAXN];
bool visited[MAXN];
int M,id,od;

void dfs(int k){
    visited[k]=true;
    for(int i=1; i<=adj[k][0]; ++i){
        int j=adj[k][i];
        if(!visited[j])
            dfs(j);
    }
}

void fdfs(int k){
    belong[k]=M;
    for(int i=1; i<=fadj[k][0]; ++i){
        int j=fadj[k][i];
        if(visited[j]&&!belong[j])
            fdfs(j);
    }
}

int n;
void solve(){

    int i,j,k;

    //kosaraju
    for(i=1; i<=n; ++i){
        if(!belong[i]){
            dfs(i);
            M++;
            fdfs(i);
            memset(visited, false, sizeof(visited));
        }
    }

    for(i=1; i<=n; ++i)
        for(k=1; k<=adj[i][0]; ++k){
            int j=adj[i][k];
            dist[belong[i]][belong[j]]=true;
        }

    for(i=1; i<=M; ++i)
        for(j=1; j<=M; ++j)
            if(i!=j&&dist[i][j]){
                outd[i]++;
                ind[j]++;
            }

    for(i=1; i<=M; ++i){
        if(ind[i]==0)
            id++;
        if(outd[i]==0)
            od++;
    }
}

void input(){
    fin>>n;
    for(int i=1; i<=n; ++i){
        int a;
        fin>>a;
        while(a!=0){
             adj[i][++adj[i][0]]=a;
            fadj[a][++fadj[a][0]]=i;
            fin>>a;
        }
    }
}

void output(){
    if(M==1)
        fout<<1<<endl<<0<<endl;
    else{
        fout<<id<<endl;
        fout<<(id>od?id:od)<<endl;
    }
}

int main(){

    input();

    solve();

    output();

    return 0;
}

小阮 2011-02-11 19:40 发表评论

USACO 5.3.2 Window Area (矩阵切割, 上浮法)

小阮 — Thu, 10 Feb 2011 15:14:00 GMT

摘要: 用一个表保存矩阵的先后顺序，w,t,b,d都对表进行操作，同时维护一个hash表查找标识符对应的下标。s时，采用上浮法得到矩阵面积。 /**//*ID: lorelei3TASK: windowLANG: C++*/#include #include using namesp... 阅读全文

小阮 2011-02-10 23:14 发表评论

USACO 5.3.1 Milk Measuring (DFSID+DP)

小阮 — Thu, 10 Feb 2011 06:18:00 GMT

本题我采用DFS+DP的方法，题意是找使用最少的桶，所有先用1个桶进行DFS枚举，再用2个，3个，等等。

枚举出使用的桶之后，DP的环节就是完全背包问题。

初始化：f[i* v[第一个桶]]=true (我试过仅f[0]也能过，就是慢点）
状态转移方程：f[j] = f[j] | f[j-v[第i个桶]；
目标状态：f[Q]

/*
ID: lorelei3
TASK: milk4
LANG: C++
*/

#include <fstream>
#include <algorithm>
#include <memory.h>

using namespace std;

const int MAXP = 105;
const int MAXQ = 20000;

int Q,P,v[MAXP];
int ans, use[MAXP];

ifstream fin("milk4.in");
ofstream fout("milk4.out");

void input(){
    fin>>Q;
    fin>>P;
    for(int i=1; i<=P; ++i)
        fin>>v[i];

    sort(v+1, v+1+P);
}

void output(){
    fout<<ans;
    for(int i=1; i<=ans; ++i)
        fout<<" "<<v[use[i]];
    fout<<endl;
    exit(0);
}

bool f[MAXQ];
void dp(){
    int i,j;
    memset(f, false, sizeof(f));
    for(i=1; i<=Q/v[use[1]]; ++i)
        f[i*v[use[1]]]=true;

    for(i=2; i<=ans; i++)
        for(j=v[use[i]]; j<=Q; ++j)
            f[j] |= f[j-v[use[i]]];

    if(f[Q])
        output();

}

void dfs(int k){
    for(int i=use[k-1]+1; i<=P-ans+k; ++i){
        use[k]=i;
        if(k==ans)
            dp();
        else
            dfs(k+1);
    }
}

void DFSID(){
    for(ans=1; ans<=P; ++ans)
        dfs(1);
}

int main(){
    input();
    DFSID();
    return 0;
}

小阮 2011-02-10 14:18 发表评论

USACO 5.2.3 Wisconsin Squares (暴搜)

小阮 — Thu, 10 Feb 2011 03:11:00 GMT

暴力搜索, 加上限制条件.

能过样例就可以了.

/*
ID: lorelei3
TASK: wissqu
LANG: C++
*/
#include <fstream>
#include <memory.h>

using namespace std;

struct Move{
    int ch,c,r;
};

ifstream fin("wissqu.in");
ofstream fout("wissqu.out");

int map[6][6], cnt[6], tot;
bool used[6][6];
Move ans[20],tmp[20];

void input(){

    char ch;
    for(int i=1; i<=4; ++i){
        for(int j=1; j<=4; ++j){
            fin>>ch;
            map[i][j]=ch-'A'+1;
            cnt[map[i][j]]++;
        }
        fin.get();
    }
    cnt[3]--;
    cnt[4]++;
}

void dfs(int d, int ch){
    if(d>=16){
        if(tot==0)
            memcpy(ans, tmp, sizeof(ans));
        tot++;
        return;
    }
    for(int i=1; i<=4; ++i)
        for(int j=1; j<=4; ++j)

            if(!used[i][j] && map[i+1][j+1]!=ch &&  map[i+1][j]!=ch && map[i+1][j-1]!=ch &&
                map[i][j+1]!=ch && map[i][j]!=ch &&map[i][j-1]!=ch &&
                map[i-1][j+1]!=ch && map[i-1][j]!=ch && map[i-1][j-1]!=ch){


                int t = map[i][j];
                map[i][j]=ch;
                cnt[ch]--;
                used[i][j]=true;
                tmp[d].ch = ch;
                tmp[d].r = i;
                tmp[d].c = j;

                if(d==15)
                    dfs(d+1, 0);
                else{
                    for(int k=1; k<=5; ++k)
                        if(cnt[k])
                            dfs(d+1, k);
                }

                map[i][j]=t;
                cnt[ch]++;
                used[i][j]=false;
            }
}

void output(){
    for(int i=0; i<16; ++i)
        fout<<(char)(ans[i].ch-1+'A')<<" "<<ans[i].r<<" "<<ans[i].c<<endl;
    fout<<tot<<endl;
}

int main(){

    input();

    dfs(0, 4);

    output();

    return 0;
}

小阮 2011-02-10 11:11 发表评论

USACO 5.2.2 Electric Fences (模拟退火算法)

小阮 — Wed, 09 Feb 2011 05:44:00 GMT

摘要: 此题就是是求费马点，可以用到模拟退火算法模拟退火的主要思想是一开始现在一个大范围内游走，逐渐减小搜索范围，最后找到解我的程序是令马尔科夫链为200（即每次循环进行200次探索），初始温度为40（随机走若干个t步），衰减量为1（每次t--），则当温度降为0时，即找到答案 /**//*ID: lorelei3TASK: fence3LANG: C++*/#include... 阅读全文

小阮 2011-02-09 13:44 发表评论

USACO 5.2.1 Snail Trail (模拟搜索)

小阮 — Tue, 08 Feb 2011 17:24:00 GMT

朴素搜索即刻, 注意终止条件和行走路线的模拟.

/*
ID: lorelei3
TASK: snail
LANG: C++
*/

#include <fstream>
#include <cmath>
#include <memory.h>

using namespace std;

const int MAXN = 125;
const int dx[] = {1, 0,-1, 0};
const int dy[] = {0, 1, 0,-1};

ifstream fin("snail.in");
ofstream fout("snail.out");

char board[MAXN][MAXN];

int n,b;
void input(){
    memset(board, '.', sizeof(board));
    fin>>n>>b;
    for(int i=0; i<b; ++i){
        fin.get();
        char ch; int a;
        fin>>ch>>a;
        board[a][ch-'A'+1]='#';
    }
}

int ans;
bool bound(int x, int y){

    if(x<1 || x>n)    return true;
    if(y<1 || y>n)    return true;
    if(board[x][y]=='#') return true;
    if(board[x][y]=='0') return true;
    return false;
}

bool terminal(int x, int y, int dir){

    if(board[x+dx[dir]][y+dy[dir]]=='0')
        return true;

    for(int i=0; i<4; ++i){
        if(abs(i-dir)==2) continue;
        int tx=x+dx[i];
        int ty=y+dy[i];

        if(tx<1||tx>n) continue;
        if(ty<1||ty>n) continue;

        if(board[tx][ty]=='.')
            return false;
    }
    return true;
}

void dfs(int x, int y, int dir,int cnt){

    if(terminal(x,y,dir)){
        if(cnt>ans)
            ans=cnt;
        return;
    }
    else{
        board[x][y]='0';

        int tx=x+dx[dir];
        int ty=y+dy[dir];

        int dt;
        if(bound(tx,ty)){

            dt=dir+1>3?0:dir+1;
            tx=x+dx[dt];
            ty=y+dy[dt];
            if(!bound(tx,ty))
                dfs(tx, ty, dt, cnt+1);

            dt=dir-1<0?3:dir-1;
            tx=x+dx[dt];
            ty=y+dy[dt];
            if(!bound(tx,ty))
                dfs(tx, ty, dt, cnt+1);
        }else
            dfs(tx, ty, dir, cnt+1);

        board[x][y]='.';
    }
}

void output(){
    fout<<ans<<endl;
}

int main(){
    input();

    dfs(1,1,0,1);
    dfs(1,1,1,1);

    output();

    return 0;
}

小阮 2011-02-09 01:24 发表评论

USACO 5.1.3 Musical Theme ( 最长重复子序列)

小阮 — Tue, 08 Feb 2011 11:09:00 GMT

将相邻的数做差之后，转换为求最长重复子序列。

/*
ID: lorelei
TASK: theme
LANG: C++
*/

#include <fstream>

using namespace std;

const int MAXN = 5005;
const int INF = 0x7FFFFFFF;

ifstream fin("theme.in");
ofstream fout("theme.out");

int a[MAXN];
int n, ans;

void input(){
    int p,q;
    fin>>n>>p;
    for(int i=1; i<n; ++i){
        fin>>q;
        a[i]=q-p;
        p=q;
    }
}

void solve(){
    for(int i=1; i<n-ans; ++i)
        for(int j=i+ans; j<n-ans; ++j)
            if(a[i]==a[j]){
                int len=1, k=j;
                while(a[i+len] == a[j+len] && i+len+1<k) len++;
                if(len>ans)
                    ans=len;
            }
}

void output(){

    if(ans<4) ans = -1;
    fout<<ans+1<<endl;
}

int main(){

    input();

    solve();

    output();

    return 0;
}

小阮 2011-02-08 19:09 发表评论

USACO 5.1.2 Starry Night (Flood Fill + hash)

小阮 — Tue, 08 Feb 2011 05:01:00 GMT

摘要: FloodFill遍历，对于个每个图形，分别进行旋转、对称total7种操作，然后在hash table中找是否存在。 /**//*ID: lorelei3TASK: starryLANG: C++*/#include #include #include 阅读全文

小阮 2011-02-08 13:01 发表评论

USACO 5.1.1 Fencing the Cows (凸包)

小阮 — Sat, 05 Feb 2011 14:16:00 GMT

凸包入门题目, 我用的是O(nlgn)的graham算法, 该算法的原理可以参照算法导论相关章节

/*
ID: lorelei3
TASK: fc
LANG: C++
*/

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>

using namespace std;

const int STACKSIZE = 1000;
const int MAXN = 10001;
const int INF = 0x7FFFFFFF;

struct Point{
    double x,y;
};

ifstream fin("fc.in");
ofstream fout("fc.out");

Point p0, points[MAXN];

double cross(Point &p1s, Point &p1e, Point &p2s, Point &p2e){
    double x1 = p1e.x - p1s.x;
    double y1 = p1e.y - p1s.y;

    double x2 = p2e.x - p2s.x;
    double y2 = p2e.y - p2s.y;

    return x1*y2-x2*y1;
}

double dis(Point &p1, Point &p2){
        return sqrt((p2.y-p1.y)*(p2.y-p1.y)+(p2.x-p1.x)*(p2.x-p1.x));
}

int cmp(const void *A, const void *B){
    Point *p1 = (Point*)A;
    Point *p2 = (Point*)B;

    double res = cross(p0, *p1, p0, *p2);
    if(res>0)
        return -1;
    else if(res==0 && dis(p0,*p1) > dis(p0, *p2))
        return  -1;
    else
        return 1;
}

int n;
void input(){
    int loc=0;
    double minx = INF, miny = INF;
    fin>>n;
    for(int i=0; i<n; ++i){
        fin>>points[i].x >>points[i].y;

        if(points[i].y < miny){
            miny = points[i].y;
            minx = points[i].x;
            p0 = points[i];
            loc = i;
        }else if(points[i].y == miny){
            if(points[i].x < minx){
                miny = points[i].y;
                minx = points[i].x;
                p0 = points[i];
                loc = i;
            }
        }
    }
    points[loc] = points[--n];

    qsort(points, n, sizeof(Point), cmp);
}

Point stack[STACKSIZE];
int top;
void graham(){

    stack[++top] = p0;
    stack[++top] = points[0];
    stack[++top] = points[1];

    for(int i=2; i<n; ++i){
        while(cross(stack[top], points[i], stack[top], stack[top-1])<0 )
            top--;
        stack[++top] = points[i];
    }
}

double ans=0;
void output(){
    int tmp = top;
    while(tmp!=1){
        ans += dis(stack[tmp], stack[tmp-1]);
        tmp--;
    }

    ans += dis(p0, stack[top]);

    fout.setf(ios::fixed);
    fout.precision(2);
    fout<<ans<<endl;

}

int main(){

    input();

    graham();

    output();

    return 0;
}

小阮 2011-02-05 22:16 发表评论

USACO 4.4.3 Frame Up (拓扑排序)

小阮 — Fri, 04 Feb 2011 08:48:00 GMT

摘要: 根据题意，每个矩形总能找到他的四个角的坐标，先找出各个矩形，再遍历每个矩形的四条边，例如：若在遍历矩形A的四条边时候，遇到B。则图中存在边A->B如此建立边的关系之后即刻拓扑排序。最后对结果进行排序。PS：结果数量比较大。 /**//*ID: lorelei3TASK: frameupLANG: C++*/#include 阅读全文

小阮 2011-02-04 16:48 发表评论

USACO 4.4.2 Pollutant Control (最大流最小割定理)

小阮 — Wed, 02 Feb 2011 05:57:00 GMT

根据最大流最小割定理，最大流的值flow就等于最小割的流量。

求最小割的边集：枚举每条边，该边的值为t，从图中去掉这条边，然后求最大流maxt。

如果 maxt + t = flow 则这条边属于最小割的边集，flow -= t 。继续枚举。

另外，为了构造解，我记录了输入的顺序并对边的大小和答案进行了排序。我看到有些牛人的题解不需要排序，学习中。

/*
ID: lorelei3
TASK: milk6
LANG: C++
*/

#include <fstream>
#include <queue>
#include <algorithm>
#include <memory.h>

using namespace std;

const int MAXM = 1005;
const int MAXN = 33;
const int INF = 0x7FFFFFFF;

ifstream fin("milk6.in");
ofstream fout("milk6.out");

struct Edge{
    int index, s, t;
    long cost ;

    bool operator < ( const Edge &e)const {
        return (cost>e.cost) || (cost==e.cost && index<e.index );
    }
};

int n,m;
int cnt;
Edge edges[MAXM];

long c[MAXN][MAXN];
long tmp[MAXN][MAXN];

void input(){
    fin>>n>>m;
    for(int i=1; i<=m; ++i){
        edges[i].index=i;
        fin>>edges[i].s>>edges[i].t>>edges[i].cost;
        c[edges[i].s][edges[i].t] += edges[i].cost;
    }
    memcpy(tmp, c, sizeof( long)*MAXN*MAXN);
}

long pre[MAXN], delta[MAXN];

bool bfs(int s, int t){

    queue<int> Q;

    memset(pre, 0, sizeof(pre));
    memset(delta, 0, sizeof(delta));

    delta[s]=INF;
    Q.push(s);

    while(!Q.empty()){
        int cur = Q.front();
        Q.pop();
        for(int i=1; i<=n; ++i){
            if(delta[i]==0 && c[cur][i]>0 ){
                delta[i] = delta[cur]<c[cur][i] ? delta[cur] : c[cur][i];
                pre[i] = cur;
                Q.push(i);
            }
        }
    }
    if(delta[t]==0)
        return false;

    return true;
}

long edmonds_karp(int s, int t){
    long ans=0;
    while(bfs(s,t)){
        for(int i=t; i!=s; i=pre[i]){
            c[pre[i]][i] -= delta[t];
            c[i][pre[i]] += delta[t];
        }
        ans += delta[t];
    }
    return ans;
}

int tot;
int ans[MAXM];
long maxflow, flow;

void solve(){

    sort(edges+1, edges+m+1);

    flow = edmonds_karp(1, n);
    maxflow = flow;

    for(int i=1; i<=m; ++i){
        long t = edges[i].cost;
        memcpy(c, tmp, sizeof( long)*MAXN*MAXN);

        c[edges[i].s][edges[i].t] -= edges[i].cost;

        long maxt = edmonds_karp(1, n);

        if(maxt+t == flow){
            ans[tot++] = edges[i].index;
            flow -= edges[i].cost;
            tmp[edges[i].s][edges[i].t] -= edges[i].cost;
        }
    }
}

void output(){
    fout<<maxflow<<" "<<tot<<endl;

    sort(ans, ans+tot);
    for(int i=0; i<tot; ++i)
        fout<<ans[i]<<endl;

}

int main(){

    input();

    solve();

    output();

    return 0;
}

小阮 2011-02-02 13:57 发表评论

USACO 4.4.1 Shuttle Puzzle (构造法求解)

小阮 — Sun, 30 Jan 2011 14:11:00 GMT

一开始想到暴搜，但是状态太多，肯定TLE。

了USACO上给出构造法求解：

3 5 6 4 2 1 3 5 7 6 4 2 3 5 4

2 1 -2 -2 -1 2 2 2 -1 -2 -2 1 2 -1

4 6 7 5 3 2 4 6 8 9 7 5 3 1 2 4 6 8 7 5 3 4 6 5

2 1 -2 -2 -1 2 2 2 1 -2 -2 -2 -2 1 2 2 2 -1 -2 -2 1 2 -1

5 7 8 6 4 3 5 7 9 10 8 6 4 2 1 3 5 7 9 11 10 8 6 4 2 3 5 7 9 8 6 4 5 7 6

2 1 -2 -2 -1 2 2 2 1 -2 -2 -2 -2 -1 2 2 2 2 2 -1 -2 -2 -2 -2 1 2 2 2 -1 -2 -2 1 2 -1

6 8 9 7 5 4 6 8 10 11 9 7 5 3 2 4 6 8 10 12 13 11 9 7 5 3 1 2 4 6 8 10 12 11 9 7 5 3 4 6 8 10 9 7 5 6 8 7

2 1 -2 -2 -1 2 2 2 1 -2 -2 -2 -2 -1 2 2 2 2 2 1 -2 -2 -2 -2 -2 -2 1 2 2 2 2 2 -1 -2 -2 -2 -2 1 2 2 2 -1 -2 -2 1 2 -1

规律很明显。

/*
ID: lorelei3
TASK: shuttle
LANG: C++
*/

#include <fstream>

using namespace std;

const int MAX = 500;

int n;
int two=2, one=1;
int a[MAX];

bool flag = true;

int main(){

    ifstream fin("shuttle.in");
    ofstream fout("shuttle.out");

    fin>>n;

    int loc=0, k=1;
    while(k!=0){

        if(k==n){
            flag=false;
            one = -one;
        }
        int t=k;
        while(t!=0){
            a[loc++] = two;
            t--;
        }
        a[loc++]=one;

        two = -two;
        one = -one;

        if(k<n && flag)
            k++;
        else
            k--;
    }

    int res=n;
    fout<<n<<" ";

    for(int i=0, cnt=2; i<loc-1; ++i,++cnt){
        if(cnt==20){
            fout<<(res+=a[i])<<endl;
            cnt=0;
        }
        else
            fout<<(res+=a[i])<<" ";
    }

    res+=a[loc-1];
    fout<<res<<endl;

    return 0;
}

小阮 2011-01-30 22:11 发表评论

USACO 4.3.4 Letter Game(预处理, 枚举)

小阮 — Sun, 30 Jan 2011 03:23:00 GMT

摘要: 对ditch里边的单词进行枚举, 需要预处理, 过滤掉不符合题意的单词. /**//*ID: lorelei3TASK: lgameLANG: C++*/#include #include #include using namespace... 阅读全文

小阮 2011-01-30 11:23 发表评论

USACO 4.3.3 Street Race(连通性,DFS)

小阮 — Sat, 29 Jan 2011 12:01:00 GMT

第一问，枚举地拿掉每个点u，看能否连通（dfs 到n），能连通的就是必需经过的点，对于点u 进行DFS，看会不会重复经过第一问中已经访问过的点，若都没有经过，则该u点符合第二问。

/*
ID: lorelei3
TASK: race3
LANG: C++
*/

#include <fstream>
#include <memory.h>

using namespace std;

const int MAX = 55;

ifstream fin("race3.in");
ofstream fout("race3.out");

int map[MAX][MAX];
int visited[MAX], ans1[MAX], ans2[MAX], cnt1, cnt2, n;

void input(){
    int i=0, in=0;
    while(fin>>in && in!=-2){
        int t=in;
        int c = ++map[i][0];
        map[i][c]=t;

        while(fin>>t && t!=-2){
            int c = ++map[i][0];
            map[i][c]=t;
        }
        i++;
    }
    fin>>in;
    n=i;
}

bool dfs1(int u){
    if(u==n)
        return true;

    for(int i=1; i<=map[u][0]; ++i){
        int v = map[u][i];
        if(visited[v]==0){
            visited[v]=1;
            if(dfs1(v))
                return true;
        }
    }
    return false;
}

bool rep;
void dfs2(int u){
    if(rep)
        return;
    if(visited[u]==2)
        return;

    visited[u]=2;
    for(int i=1; i<=map[u][0]; ++i){
        int v = map[u][i];
        if(visited[v]==1){
            rep=true;
            return;
        }
        dfs2(v);
    }
}

void solve(){
    for(int i=1; i<n; ++i){
        memset(visited, 0, sizeof(visited));
        visited[i]=1;
        visited[0]=1;
        if(!dfs1(0)){
            ans1[cnt1++] = i;
            rep = false;
            dfs2(i);
            if(rep == false)
                ans2[cnt2++] = i;
        }
    }
}

void output(){
    int i;
    fout<<cnt1;

    if(cnt1!=0){
        fout<<" ";
        for(i=0; i<cnt1-1; ++i)
            fout<<ans1[i]<<" ";
        fout<<ans1[cnt1-1];
    }
    fout<<endl;

    fout<<cnt2;
    if(cnt2!=0){
        fout<<" ";
        for(i=0; i<cnt2-1; ++i)
            fout<<ans2[i]<<" ";
        fout<<ans2[cnt2-1];
    }
    fout<<endl;
}

int main(){

    input();

    solve();

    output();

    return 0;
}

小阮 2011-01-29 20:01 发表评论

USACO 4.3.2 The Primes( 筛法求素数, 搜索)

小阮 — Fri, 28 Jan 2011 16:07:00 GMT

摘要: 做了一天. AC的速度还可以, 时间最长的 0.16s.1. 开始做之前，要确定下搜索顺序, 这个很关键. &... 阅读全文

小阮 2011-01-29 00:07 发表评论

USACO 4.3.1 Buy Low, Buy Lower(最长下降子序列, 高精度加法)

小阮 — Wed, 26 Jan 2011 16:59:00 GMT

第一问，求最长下降子序列长度。

设a表示数据，len(i)=前i个数中最长下降子序列长度，状态转移方程 len (i)=max{len(j)+1}(ja[i]), 初始化f[i]=1 (i=0...n-1);

第二问：

对于c[i]=前i个数中最长下降子序列的个数，状态转移方程 c[i]=sigma(c[j]) (ja[i], len[i]==len[j]+1)

对于重复情况，每一个可能重复的下降的子序列，它一定是a , b, b (a>b)的情况，开一个数组visited记录b是否出现过，若出现了，就不再计算。

状态转移方程： c[i]=sigma(c[j]) (ja[i], len[i]==len[j]+1)，visited[j]=false)。

最后是高精度加法，我的版本是每一位存一个数，有待改进。

PS：这次代码风格有点变化。

/*
ID: lorelei3
TASK: buylow
LANG: C++
*/

#include <fstream>
#include <memory.h>

using namespace std;

const int  MAXN = 5000;
const int MAXP = 50;

class HPNum{
public:
    int length;
    int num[MAXP];

    HPNum(){
        length=1;
        memset(num,0,sizeof(num));
    }

    void plus(HPNum &p){
        int len = length>p.length ? length : p.length;
        for(int i=0; i<len; ++i){
            num[i] = num[i]+p.num[i];
            if(num[i]>=10){
                num[i]-=10;
                num[i+1]++;
            }

        }
        if(num[len]>0)
            len++;
        length=len;
    }
};

int n;
long maxlen;
long a[MAXN], len[MAXN];
bool visited[20000];
HPNum c[MAXN];

ifstream fin("buylow.in");
ofstream fout("buylow.out");

void input(){
    fin>>n;
    for(int i=0; i<n; ++i){
        fin>>a[i];
        len[i]=1;
    }
}

void dp(){
    int i,j;
    maxlen=1;
    for(i=1; i<n; ++i)
        for(j=i-1; j>=0; --j){
            if(a[i]<a[j] && len[i]<len[j]+1)
                len[i] = len[j]+1;
            if(maxlen<len[i])
                maxlen = len[i];
        }

    for(i=0; i<n; ++i)
        if(len[i]==1){
            c[i].length=1;
            c[i].num[0]=1;
        }else{
            memset(visited, false, sizeof(visited));
            for(j=i-1; j>=0; --j){
                if(len[i]==len[j]+1 && !visited[a[j]] && a[i]<a[j]){
                    c[i].plus(c[j]);
                    visited[a[j]]=true;
                }
            }
        }
}

void output(){
    int i;
    HPNum sum;
    sum.length=1;
    sum.num[0]=0;
    memset(visited, false, sizeof(visited));
    for(i=n-1; i>=0; --i)
        if(len[i]==maxlen && !visited[a[i]]){
            sum.plus(c[i]);
            visited[a[i]]=true;
        }

    fout<<maxlen<<" ";

    for(i=sum.length-1; i>=0; --i)
        fout<<sum.num[i];

    fout<<endl;
}

int main(){

    input();

    dp();

    output();

    return 0;
}

小阮 2011-01-27 00:59 发表评论

USACO 4.2.4 Cowcycles (DFS, 剪枝)

小阮 — Wed, 26 Jan 2011 04:03:00 GMT

参考了USACO上的提示:

1. 最大传动比率至少是最小的3倍。这个其实不用算出比率再判断，只要不满足s1[F]/s2[1]-s1[1]/s2[R]>=3的都剪掉 .

2. 用memcpy函数会更快.

3. 用插入排序对于规模较小的数据速度比较客观.

/*
ID: lorelei3
TASK: cowcycle
LANG: C++
*/

#include <fstream>
#include <memory.h>

using namespace std;

const int MAX = 100;

int F, R, F1, F2, R1, R2;
int s1[MAX], s2[MAX];
int ans1[MAX], ans2[MAX];
double rate[MAX*MAX], diff[MAX*MAX];
double minf = 0x7FFFFFFF;

void count(){
    int i,j,k=0;
    double sum1=0, sum2=0, t=0;

    for(i=1; i<=F; ++i)
        for(j=1; j<=R; ++j){
            t = (double)s1[i]/s2[j];
            int p=++k;
            while(rate[p-1]>=t){
                rate[p] = rate[p-1];
                p--;
            }
            rate[p] = t;
        }

    int cnt = F*R;
    for(i=1; i<=cnt-1; ++i){
        diff[i] = rate[i+1] - rate[i];
        sum1 += diff[i];
    }

    double mean = sum1/(cnt-1);

    for(i=1; i<=cnt-1; ++i)
        sum2+=(diff[i]-mean)*(diff[i]-mean);

    double var = sum2/cnt-1;

    if(var<minf){
        minf = var;
        memcpy(ans1+1, s1+1, sizeof(int)*F);
        memcpy(ans2+1, s2+1, sizeof(int)*R);
    }
}

void dfs2(int k, int w){
    if(k==R+1){
        if(s1[F]*s2[R]<3*(s1[1]*s2[1]) )
            return;
        count();
        return;
    }else{
        for(int i=w; i<=R2-(R-k); ++i){
            s2[k]=i;
            dfs2(k+1, i+1);
        }
    }
}

void dfs1(int k, int w){
    if(k==F+1){
        dfs2(1, R1);
        return;
    }else{
        for(int i=w; i<=F2-(F-k); ++i){
            s1[k]=i;
            dfs1(k+1, i+1);
        }
    }
}

int main(){

    ifstream fin("cowcycle.in");
    ofstream fout("cowcycle.out");

    fin>>F>>R>>F1>>F2>>R1>>R2;

    dfs1(1,F1);

    int i;
    for(i=1; i<=F-1; ++i)
        fout<<ans1[i]<<" ";
    fout<<ans1[F]<<endl;

    for(i=1; i<=R-1; ++i)
        fout<<ans2[i]<<" ";
    fout<<ans2[R]<<endl;

    return 0;
}

小阮 2011-01-26 12:03 发表评论

USACO 4.2.3 Job Processing (平均贪心)

小阮 — Tue, 25 Jan 2011 09:10:00 GMT

1. 用贪心分别算出A单独加工n个工件的时间f1, 和B单独加工n个工件的时间f2

2. 用f1 的最小值 + f2 最大值 , 用平均贪心的思想. 再比较最大值为第二问的解.

/*
ID: lorelei3
TASK: job
LANG: C++
*/

#include <fstream>
#include <algorithm>
#include <functional>

using namespace std;

const int MAXN = 1005;
const int MAXM = 35;

int t1[MAXM], t2[MAXM], w1[MAXM], w2[MAXM], f1[MAXN], f2[MAXN];

int main(){
    int i,j, n, m1, m2;

    ifstream fin("job.in");
    ofstream fout("job.out");

    fin>>n>>m1>>m2;

    for(i=1; i<=m1; ++i)
        fin>>t1[i];

    for(i=1; i<=m2; ++i)
        fin>>t2[i];

    for(i=1; i<=n; ++i){
        int min=1;
        for(j=2; j<=m1; ++j)
            if(w1[j]+t1[j] < w1[min]+t1[min])
                min=j;
        w1[min] += t1[min];
        f1[i] = w1[min];

        min=1;
        for(j=2; j<=m2; ++j)
            if(w2[j]+t2[j] < w2[min]+t2[min])
                min =j;
        w2[min] += t2[min];
        f2[i] = w2[min];
    }

    sort(f1+1, f1+n+1, less<int>());
    sort(f2+1, f2+n+1, greater<int>());

    int ans1 = f1[n], ans2 = 0;

    for(i=1; i<=n; ++i)
        if(f1[i]+f2[i] > ans2)
            ans2 = f1[i]+f2[i];

    fout<<ans1<<" "<<ans2<<endl;

    return 0;
}

小阮 2011-01-25 17:10 发表评论