C++博客-止于自娱-随笔分类-USACO

USACO 4.1 Fence Loops

YZY — Fri, 17 Jul 2009 06:26:00 GMT

摘要: 求无向图中的一个最小环的长度阅读全文

YZY 2009-07-17 14:26 发表评论

USACO 4.1 Beef McNuggets

YZY — Sun, 12 Jul 2009 06:58:00 GMT

这题有些难。虽然知道是动态规划题，但是不知道要开多大的数组，后来看analysis用一个256大小的数组循环使用，方法很巧妙。
先将box进行排序。
如果box里面的数的最大公约数不为1的话，那么所有组成的数，只可能是这个公约数的倍数，因此没有上限，输出为0.
用last记录最小的“不能组成的数”。这样当last之后有boxs[0]个连续数都可以组成的话，那么所有的数都可以组成。
last+1...last+box[0]可以组成的话，那么每个数都加一个box[0],那么新一轮的box[0]个数也可以组成，以此类推。

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int box_num;
int boxs[10];

bool ok[256];

int gcd(int a,int b)
{
    if(a<b) swap(a,b);

    int tmp;

    while(b!=0){
        tmp = a;
        a = b;
        b = tmp%b;
    }

    return a;
}

void solve()
{

    in>>box_num;
    for(int i=0;i<box_num;++i)
        in>>boxs[i];

    sort(&boxs[0],&boxs[box_num]);

    int t = boxs[0];

    for(int i=1;i<box_num;++i){
        t = gcd(t,boxs[i]);
    }

    if(t!=1){
        out<<0<<endl;
        return;
    }

    memset(ok,0,sizeof(ok));

    int last = 0;
    ok[0] = true;
    int i=0;

    while(true){
        if(ok[i%256]){
            ok[i%256] = 0;
            if(i-last>=boxs[0]){
                out<<last<<endl;
                return;
            }
            for(int x=0;x<box_num;++x){
                ok[(i+boxs[x])%256] = true;
            }
        }else{
            last = i;
        }
        ++i;
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

Beef McNuggets

Hubert Chen

Farmer Brown's cows are up in arms, having heard that McDonalds is considering the introduction of a new product: Beef McNuggets. The cows are trying to find any possible way to put such a product in a negative light.

One strategy the cows are pursuing is that of `inferior packaging'. ``Look,'' say the cows, ``if you have Beef McNuggets in boxes of 3, 6, and 10, you can not satisfy a customer who wants 1, 2, 4, 5, 7, 8, 11, 14, or 17 McNuggets. Bad packaging: bad product.''

Help the cows. Given N (the number of packaging options, 1 <= N <= 10), and a set of N positive integers (1 <= i <= 256) that represent the number of nuggets in the various packages, output the largest number of nuggets that can not be purchased by buying nuggets in the given sizes. Print 0 if all possible purchases can be made or if there is no bound to the largest number.

The largest impossible number (if it exists) will be no larger than 2,000,000,000.

PROGRAM NAME: nuggets

INPUT FORMAT

Line 1:	N, the number of packaging options
Line 2..N+1:	The number of nuggets in one kind of box

SAMPLE INPUT (file nuggets.in)

OUTPUT FORMAT

The output file should contain a single line containing a single integer that represents the largest number of nuggets that can not be represented or 0 if all possible purchases can be made or if there is no bound to the largest number.

SAMPLE OUTPUT (file nuggets.out)

YZY 2009-07-12 14:58 发表评论

USACO 3.4 Raucous Rockers

YZY — Sat, 11 Jul 2009 03:48:00 GMT

一开始把题意理解错了，以为刻在同一张光盘上的歌曲的时间顺序不变就可以了。
事实上不仅同光盘上的歌曲写入时间要按顺序，前一张光盘上的歌曲不能比后一张歌曲写入时间要晚。

数据量比较少，用回溯法，dp也行。

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int capacity[20];;
int songs[20];
int song_num,disk_num;

int res = 0;
int cur;

void backtracing(int depth,int last)
{
    if(depth==song_num){
        if(cur>res){
            res = cur;
        }
        return;
    }

    //如果后面所有的歌曲都加上还比最优值小，剪枝
    if(cur+song_num-depth<=res)
       return;

    for(int i=last;i<disk_num;++i){
         //如果当前歌曲需要刻录，那只需刻在第一张能装得下的光盘上。
        if( capacity[i]>=songs[depth]){
            cur++;
            capacity[i]-=songs[depth];
            backtracing(depth+1,i);
            capacity[i]+=songs[depth];
            cur--;
            break;
        }
    }

    // 不刻当前歌曲
    backtracing(depth+1,last);

}

void solve()
{
    int c;
    in>>song_num>>c>>disk_num;

    for(int i=0;i<song_num;++i)
        in>>songs[i];

    for(int i=0;i<disk_num;++i)
        capacity[i] = c;

    backtracing(0,0);

    out<<res<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-11 11:48 发表评论

USACO 3.4 Electric Fence

YZY — Fri, 10 Jul 2009 14:19:00 GMT

用一根平行x轴的直线扫描三角形，求交点，然后计算中间点的数，求和即可。

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

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

void solve()
{
    int n,m,p;
    in>>n>>m>>p;

    int res = 0;

    int s,e;
    for(int y=1;y<m;++y){
        s = n*y/m+1;
        e = ( y*(n-p)%m==0 ) ? (y*(n-p)/m-1+p) : floor(((double)y*(n-p)/m)+p);
      //  out<
        res += max(0,(e-s+1));
    }

    out<<res<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-10 22:19 发表评论

USACO 3.4 American Heritage

YZY — Fri, 10 Jul 2009 10:51:00 GMT

摘要: 给出一个树的中序遍历和先序遍历，求它的后序遍历。阅读全文

YZY 2009-07-10 18:51 发表评论

USACO 3.3 A Game

YZY — Thu, 09 Jul 2009 05:50:00 GMT

动态规划法。
用dp[player][start][end]表示player在[start..end]会取得的最大值。
如果player==0，那么player有主动权，它要么选start,要么选end.显然，它要选使得对手得分最少的那一个。
当它选start时，对手所能到的最大值为dp[1][start+1][end]。当它选end时，对手所选的最大值是dp[1][start][end-1].
。所以我们选dp[1][start+1][end]和dp[1][start][end-1]中小的那一个。
如果player==1，那只能被动的等0先选了。1在剩下区段中，又作为先选的角色，即player0。
当只有一个数字的时候，player0就只有选这个，player1就没得选，返回0.
代码如下：

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int dp[2][100][100];
int sequence[100];

int score(int player,int start,int end)
{
    if(dp[player][start][end]!=-1)
        return dp[player][start][end];

    if(start==end){
        if(player==0)
            dp[player][start][end] = sequence[start];
        else
            dp[player][start][end] = 0;
    }else{
        int t1 = score(0,start+1,end);
        int t2 = score(0,start,end-1);
        if(player==0){
            if(t1>t2){
                dp[player][start][end] = sequence[end]+score(1,start,end-1);
            }else{
                dp[player][start][end] = sequence[start]+score(1,start+1,end);
            }
        }else{
            if(t1>t2){
                dp[player][start][end] = score(0,start,end-1);
            }else{
                dp[player][start][end] = score(0,start+1,end);
            }
        }
    }

    return dp[player][start][end];
}

void solve()
{
    memset(dp,-1,sizeof(dp));

    int size;
    in>>size;

    for(int i=0;i<size;++i)
        in>>sequence[i];

    out<<score(0,0,size-1)<<" "<<score(1,0,size-1)<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-09 13:50 发表评论

USACO 3.3 Home on the Range

YZY — Wed, 08 Jul 2009 09:44:00 GMT

dp题。用dp[i][j][m]表示左上角为(i,j)，边长为m的正方形是否完整。那么
如果dp[i][j][m]完整，则当且仅当dp[i][j][m-1],dp[i+1][j][m-1],dp[i][j+1][m-1],dp[i+1][j+1][m-1]的正方形也是完整的(画个图就很清晰了)。由于我们从上到下，从左到右扫描每个点，在每一轮i,j用过一次，就不会再使用，所以只需用二维数组保存dp[i][j]，即可。
时间复杂度为O(n^3),空间复杂度为O(n^2)。analysis中有个时间复杂度为O(n^2),空间O(n)的解法。

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

bool dp[250][250];
int side_len;

void input()
{
    in>>side_len;

    char t;

    for(int i=0;i<side_len;++i){
        for(int j=0;j<side_len;++j){
            while( in.get(t)&&isspace(t) );
            dp[i][j] = t-'0';
        }
    }
}

void solve()
{
    input();

    for(int w = 2;w<=side_len;++w){
        int cnt = 0;

        for(int i=0;i<side_len;++i){
            for(int j=0;j<side_len;++j){
                if(i+w<=side_len&&j+w<=side_len){
                    dp[i][j] = dp[i][j]&&dp[i+1][j]&&dp[i][j+1]&&dp[i+1][j+1];
                    if(dp[i][j])
                        cnt++;
                }
            }
        }

        if(cnt!=0){
            out<<w<<" "<<cnt<<endl;
        }
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-08 17:44 发表评论

USACO 3.3 Riding The Fences

YZY — Tue, 07 Jul 2009 08:59:00 GMT

摘要: 欧拉路径阅读全文

YZY 2009-07-07 16:59 发表评论

USACO 3.2 Sweet Butter

YZY — Mon, 06 Jul 2009 12:05:00 GMT

摘要: 稀疏图的多源最短路径问题阅读全文

YZY 2009-07-06 20:05 发表评论

USACO 3.2 Magic Squares

YZY — Mon, 06 Jul 2009 12:01:00 GMT

BFS搜索题。代码写的比较乱，用一个set来存储已经访问过的结点。analysis中的标程有不少可以学习的地方，如几个操作的变换，用转换数组来写，代码清晰明了，encode方法就省去了set。我通过保存整个树来输出解，标程通过反向操作，来输出解，做法很巧妙。

#include <iostream>
#include <fstream>
#include <set>
#include <queue>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int final[8];
set<int>visited;
char result[8*7*6*5*4*3*2*1+1];

struct queue_node{
    int current[8];
    queue_node *parent;
    char op;
};

void op(int *current,char c)
{
    int tmp;
    switch(c){
        case 'A':
            for(int i=0;i<4;++i)
                swap(current[i],current[7-i]);
            break;
        case 'B':
            tmp = current[3];
            for(int i=3;i>=1;--i)
                current[i] = current[i-1];
            current[0] = tmp;
            tmp = current[4];
            for(int i=4;i<=6;++i)
                current[i] = current[i+1];
            current[7] = tmp;
            break;
        case 'C':
            tmp = current[6];
            current[6] = current[5];
            current[5] = current[2];
            current[2] = current[1];
            current[1] = tmp;
            break;
    }
}

int cur_value(int *cur)
{
    int res = 0;
    for(int i=0;i<8;++i){
        res*=10;
        res+=cur[i];
    }

    return res;
}

void solve()
{
    for(int i=0;i<8;++i){
        in>>final[i];
    }

    queue<queue_node*> q;
    queue_node *node = new queue_node;
    for(int i=0;i<8;++i)
        node->current[i] = i+1;

    node->parent = NULL;

    q.push(node);

    while( !q.empty() ){
        queue_node *node = q.front();
        q.pop();

        int cur = cur_value(node->current);
        if( visited.find( cur) != visited.end())
            continue;
        visited.insert(cur);

        bool ok = true;
        for(int i=0;i<8;++i){
            if(node->current[i]!=final[i]){
                ok = false;
                break;
            }
        }

        if(ok){
            int i = 0;
            while(node->parent!=NULL){
                result[i++] = node->op;
                node=node->parent;
            }

            if(i==0){
                out<<0<<endl<<endl;
                exit(0);
            }

            out<<i<<endl;

            int j;
            i--;
            for(j=0;i>=0;i--,j++){
                out<<result[i];
                if(j%60==59) out<<endl;
            }

            if(j%60!=0)
                out<<endl;

            exit(0);
        }

        for(char c='A';c<='C';++c){
            queue_node * n = new queue_node;
            memcpy(n->current,node->current,sizeof(node->current));
            op(n->current,c);
            n->op = c;
            n->parent = node;
            q.push(n);
        }
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-06 20:01 发表评论

USACO 3.2 Spinning Wheels

YZY — Sat, 04 Jul 2009 12:49:00 GMT

最多转360秒，各个轮子就复位了。所以在360秒内，每过一秒检测一下是否可以透过光即可。
用一个数组记录能透过0-359的轮子的个数，当在某一度轮子的个数达到了5，则说明光可以透过，输出即可。
否则说明是不可能有光透过。

#include <iostream>
#include <fstream>

using namespace std;

ifstream in("spin.in");
ofstream out("spin.out");

struct wedge{
    int start;
    int extent;
};

int speed[5];
wedge wedges[5][5];
int wedge_num[5];

void onesecond()
{
   for(int i=0;i<5;++i){
       for(int j=0;j<wedge_num[i];++j){
           wedges[i][j].start+=speed[i];
           wedges[i][j].start%=360;
       }
   }
}

bool isok()
{
    int tmp[360];

    memset(tmp,0,sizeof(tmp));

    for(int i=0;i<5;++i){
        for(int j=0;j<wedge_num[i];++j){
            for(int k=0;k<=wedges[i][j].extent;++k)
                tmp[(wedges[i][j].start+k)%360]++;
        }
    }

    for(int i=0;i<360;++i)
        if(tmp[i]==5)
            return true;

    return false;
}

void solve()
{
    for(int i=0;i<5;++i){
        in>>speed[i];
        in>>wedge_num[i];
        for(int j=0;j<wedge_num[i];++j){
            in>>wedges[i][j].start>>wedges[i][j].extent;
        }
    }

    if(isok()){
        out<<0<<endl;
        return;
    }

    for(int i=1;i<=360;++i){
        onesecond();
        if(isok()){
            out<<i<<endl;
            return;
        }
    }
    out<<"none"<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-07-04 20:49 发表评论

USACO 3.2 Stringsobits

YZY — Fri, 03 Jul 2009 12:45:00 GMT

首先计算出组合数。用cmb_num[i][j]表示i位数中，"1的位数小于等于j"的数的个数。
这样，我们从最左边开始，如果cmb_num[i-1][j]的数大于n，说明第一位为0，因为用i-1位数中"1的位数小于等于j"的数已经大于n个了。
如果小于n，说明第一位为1，需要i位，才能使"1的位数小于等于j"的数大于n个了。既然第一位已经是1了，接下来的i-1位组成的数的1的个数只能小于等于n-1位了。迭代输出每一位即可。
只是要注意溢出的问题以及cmb_num[0][1]。

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

unsigned int cmb_num[32][32];

void build_cmb_num()
{
    for(int i=0;i<32;++i)
        cmb_num[i][0] = 1;

    for(int i=1;i<32;++i)
        for(int j=1;j<=i;++j)
            cmb_num[i][j] = cmb_num[i-1][j-1]+cmb_num[i-1][j];

    for(int i=0;i<32;++i)
        for(int j=1;j<32;++j){
            cmb_num[i][j]+=cmb_num[i][j-1];
        }
}

void solve()
{
    build_cmb_num();

    unsigned  n,l,i;
    in>>n>>l>>i;

    for(unsigned idx=n;idx>0;--idx){
        if( i> cmb_num[idx-1][l] ){
            out<<1;
            i-=cmb_num[idx-1][l];
            l--;
        }else{
            out<<0;
        }
    }

    out<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

附题：
Stringsobits
Kim Schrijvers

Consider an ordered set S of strings of N (1 <= N <= 31) bits. Bits, of course, are either 0 or 1.

This set of strings is interesting because it is ordered and contains all possible strings of length N that have L (1 <= L <= N) or fewer bits that are `1'.

Your task is to read a number I (1 <= I <= sizeof(S)) from the input and print the Ith element of the ordered set for N bits with no more than L bits that are `1'.

PROGRAM NAME: kimbits

INPUT FORMAT

A single line with three space separated integers: N, L, and I.

SAMPLE INPUT (file kimbits.in)

5 3 19

OUTPUT FORMAT

A single line containing the integer that represents the Ith element from the order set, as described.

SAMPLE OUTPUT (file kimbits.out)

YZY 2009-07-03 20:45 发表评论

USACO 3.2 Factorials

YZY — Fri, 03 Jul 2009 11:52:00 GMT

这题主要是去掉阶乘末尾的0。是个老题了，编程之美中就有讨论。因为0都是由2*5得来的。只要找出乘数中有多少个2*5对就行了。
因为2的个数远多于5，所以只要找出5的个数即可。因为n最大为4220,5的个数为:
n/5+n/5/5+n/5/5/5+n/5/5/5/5+n/5/5/5/5/5+n/5/5/5/5/5/5;
然后再去除相应数目的2。这样剩下的数只需两两相乘后取最后一位即可。

#include <iostream>
#include <fstream>

using namespace std;

ifstream in("fact4.in");
ofstream out("fact4.out");

void solve()
{
    int n;
    in>>n;

    int numof5 = n/5+n/5/5+n/5/5/5+n/5/5/5/5+n/5/5/5/5/5+n/5/5/5/5/5/5;

    int res = 1;

    int tmp;

    for(int i=1;i<=n;++i){
        tmp = i;
        while(tmp%5==0) tmp/=5;
        while(tmp%2==0&&numof5!=0){
            tmp/=2;
            numof5--;
        }
        res*=tmp;
        res%=10;
    }

    out<<res<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

原题：
Factorials

The factorial of an integer N, written N!, is the product of all the integers from 1 through N inclusive. The factorial quickly becomes very large: 13! is too large to store in a 32-bit integer on most computers, and 70! is too large for most floating-point variables. Your task is to find the rightmost non-zero digit of n!. For example, 5! = 1 * 2 * 3 * 4 * 5 = 120, so the rightmost non-zero digit of 5! is 2. Likewise, 7! = 1 * 2 * 3 * 4 * 5 * 6 * 7 = 5040, so the rightmost non-zero digit of 7! is 4.

PROGRAM NAME: fact4

INPUT FORMAT

A single positive integer N no larger than 4,220.

SAMPLE INPUT (file fact4.in)

OUTPUT FORMAT

A single line containing but a single digit: the right most non-zero digit of N! .

SAMPLE OUTPUT (file fact4.out)

YZY 2009-07-03 19:52 发表评论

USACO 3.1 Contact

YZY — Thu, 02 Jul 2009 14:07:00 GMT

字符串的长度有限(最多只有12位)，我建一个trie树来存储所有字符串，然后遍历trie树，将对应的字符串存储到一个vector中，再排序输出。
ac以后，看usaco的分析，是用位串来做索引计数，这种方法比较简洁巧妙。为了解决前缀为0的问题，在每个字符串前面加了一个1，输出的时候再去掉。
我的解法如下：

#include <iostream>
#include <fstream>
#include <vector>
#include <string>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

struct trie_node{
    int cnt;
    trie_node* sons[2];
    trie_node(){
        sons[0] = sons[1] = 0;
        cnt = 0;
    }
};

struct sort_node{
    string str;
    int cnt;

    bool operator<(const sort_node&n2) const{
        if(cnt!=n2.cnt) return cnt>n2.cnt;
        if(str.size()!=n2.str.size()) return str.size()<n2.str.size();
        for(int i=0;i<str.size();++i){
            if(str[i]!=n2.str[i])
                return str[i]<n2.str[i];
        }
    }
};

char buf[200000];
int buf_len;
int a,b,n;
vector<sort_node>res;

void insert_trie(trie_node*root,const char *start,int len)
{
    trie_node * next = root;

    for(int i=0;i<len;++i){
        if(next->sons[start[i]-'0']==NULL)
            next->sons[start[i]-'0'] = new trie_node;
        next = next->sons[start[i]-'0'];
        if(i+1>=a&&i+1<=b)
            next->cnt++;
    }
}

void _traverse_trie(trie_node *root,char ch,int depth)
{
    if(root==NULL) return;

    buf[depth]=ch;

    if(root->cnt!=0){
        sort_node n;
        n.str = string(&buf[0],&buf[depth+1]);
        n.cnt = root->cnt;
        res.push_back(n);
    }

    _traverse_trie(root->sons[0],'0',depth+1);
    _traverse_trie(root->sons[1],'1',depth+1);
}

void traverse_trie(trie_node *root)
{
    _traverse_trie(root->sons[0],'0',0);
    _traverse_trie(root->sons[1],'1',0);
}

void solve()
{
    in>>a>>b>>n;

    char ch;
    while(in.get(ch)){
        if(ch=='0'||ch=='1')
            buf[buf_len++] = ch;
    }

    trie_node root;

    for(int i=0;i+b<=buf_len;++i){
        insert_trie(&root,&buf[i],b);
    }

    for(int i=min(b-1,buf_len);i>=a;--i){
        insert_trie(&root,&buf[buf_len-i],i);
    }

    traverse_trie(&root);

    sort(res.begin(),res.end());

    int freq_cnt = 0;
    int last_cnt = -1;
    int out_cnt = 0;

    for(int i=0;i<res.size();++i){
        if(res[i].cnt==last_cnt){
            if(out_cnt%6!=0)
            out<<" ";
            out<<res[i].str;
            out_cnt++;
            if(out_cnt%6==0||i==(res.size()-1)||res[i+1].cnt!=res[i].cnt)
                out<<endl;
        }else{
            last_cnt = res[i].cnt;
            freq_cnt++;
            if(freq_cnt>n)
               break;
            out<<res[i].cnt<<endl;
            out<<res[i].str;
            out_cnt = 0;
            out_cnt++;
            if( (i==res.size()-1)||res[i+1].cnt!=res[i].cnt)
                out<<endl;
        }
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

附题：
Contact
IOI'98

The cows have developed a new interest in scanning the universe outside their farm with radiotelescopes. Recently, they noticed a very curious microwave pulsing emission sent right from the centre of the galaxy. They wish to know if the emission is transmitted by some extraterrestrial form of intelligent life or if it is nothing but the usual heartbeat of the stars.

Help the cows to find the Truth by providing a tool to analyze bit patterns in the files they record. They are seeking bit patterns of length A through B inclusive (1 <= A <= B <= 12) that repeat themselves most often in each day's data file. They are looking for the patterns that repeat themselves most often. An input limit tells how many of the most frequent patterns to output.

Pattern occurrences may overlap, and only patterns that occur at least once are taken into account.

PROGRAM NAME: contact

INPUT FORMAT

Line 1:	Three space-separated integers: A, B, N; (1 <= N < 50)
Lines 2 and beyond:	A sequence of as many as 200,000 characters, all 0 or 1; the characters are presented 80 per line, except potentially the last line.

SAMPLE INPUT (file contact.in)

2 4 10
01010010010001000111101100001010011001111000010010011110010000000

In this example, pattern 100 occurs 12 times, and pattern 1000 occurs 5 times. The most frequent pattern is 00, with 23 occurrences.

OUTPUT FORMAT

Lines that list the N highest frequencies (in descending order of frequency) along with the patterns that occur in those frequencies. Order those patterns by shortest-to-longest and increasing binary number for those of the same frequency. If fewer than N highest frequencies are available, print only those that are.

Print the frequency alone by itself on a line. Then print the actual patterns space separated, six to a line (unless fewer than six remain).

SAMPLE OUTPUT (file contact.out)

23
00
15
01 10
12
100
11
11 000 001
10
010
8
0100
7
0010 1001
6
111 0000
5
011 110 1000
4
0001 0011 1100

YZY 2009-07-02 22:07 发表评论

USACO 3.1 Stamps

YZY — Tue, 30 Jun 2009 12:37:00 GMT

摘要: 动态规划题阅读全文

YZY 2009-06-30 20:37 发表评论

USACO 3.1 Humble Numbers

YZY — Mon, 29 Jun 2009 16:05:00 GMT

摘要: 二分法阅读全文

YZY 2009-06-30 00:05 发表评论

USACO 3.1 Score Inflation

YZY — Mon, 29 Jun 2009 14:21:00 GMT

摘要: 背包问题阅读全文

YZY 2009-06-29 22:21 发表评论

USACO 3.1 Agri-Net

YZY — Mon, 29 Jun 2009 13:48:00 GMT

摘要: 最小生成树问题
阅读全文

YZY 2009-06-29 21:48 发表评论

USACO 2.4 Fractions to Decimals

YZY — Sun, 28 Jun 2009 10:49:00 GMT

摘要: 模拟题，将分数转换成带循环节小数形式。阅读全文

YZY 2009-06-28 18:49 发表评论

USACO 2.4 Bessie Come Home

YZY — Sun, 28 Jun 2009 09:25:00 GMT

摘要: 最短路径问题阅读全文

YZY 2009-06-28 17:25 发表评论

USACO 2.4 Cow Tours

YZY — Sat, 27 Jun 2009 14:10:00 GMT

这题综合了dfs,floyd算法。

首先用 floyd计算出两两之间的最短路径。然后用dfs将图着色。对每两两不同颜色的结点，我们把它们相连，然后看产生的图的直径的大小。
直径的大小只可能仍为原两连通图直径之一，或者是包括新添加的路径所产生的最长路径，取这三者中的最大值。新路径产生的最长路径只可能是两点的距离加上两点到其他点的最长距离。最开始的时候只考虑了新添加的路径，没考虑原直径会比新路径大的情况，wa了n次。。

#include <iostream>
#include <fstream>

#include <cfloat>
#include <cmath>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

double path[150][150];

char graph[150][150];

int x[150];
int y[150];

int n;

int color[150];

double diameter[150];
double maxPath[150];

void floyd()
{
    for(int k=0;k<n;++k)
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j){
                if(i!=j){
                    path[i][j]=min(path[i][j],path[i][k]+path[k][j]);
                }
            }
}

void make_color(int i,int c)
{
    if( color[i]!=0 )
        return;

    color[i] = c;

    for(int j=0;j<n;++j){
        if(color[j]==0&&graph[i][j])
            make_color(j,c);
    }
}

void solve()
{
    in>>n;

    for(int i=0;i<n;++i){
        in>>x[i]>>y[i];
    }

    for(int i=0;i<n;++i){
        string s;
        in>>s;
        for(int j=0;j<n;++j){
            graph[i][j]=s[j]-'0';
            if(graph[i][j]){
                path[i][j] = sqrt( (x[i]-x[j])*(x[i]-x[j])
                    +(y[i]-y[j])*(y[i]-y[j]) );
            }else{
                path[i][j] = DBL_MAX/4;
            }
        }
    }

    floyd();

    int c = 0;
    for(int i=0;i<n;++i)
        if(color[i]==0)
            make_color(i,++c);

    for(int i=0;i<n;++i){
        maxPath[i] = 0;
        for(int j=0;j<n;++j){
            if(i!=j&&color[i]==color[j]){
                maxPath[i] = max(maxPath[i],path[i][j]);
            }
        }

        diameter[color[i]] = max(diameter[color[i]],maxPath[i]);
    }

    double dia = DBL_MAX;

    for(int i=0;i<n;++i)
        for(int j=i+1;j<n;++j){

            if(color[i]==color[j]) continue;

            double d1 = 0;
            for(int p=0;p<n;++p){
                if(i!=p&&color[i]==color[p])
                    d1 = max(d1,path[i][p]);
            }

            double d2 = 0;
            for(int p=0;p<n;++p){
                if(j!=p&&color[j]==color[p])
                    d2 = max(d2,path[j][p]);
            }

            double dist = sqrt( (x[i]-x[j])*(x[i]-x[j])+
                    (y[i]-y[j])*(y[i]-y[j]) );

            dia = min(dia,max(d1+d2+dist,max(diameter[color[i]],diameter[color[j]])) );
        }

    out.setf(ios::fixed,ios::floatfield);
    out.precision(6);
    out<<dia<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-27 22:10 发表评论

USACO 2.4 Overfencing

YZY — Fri, 26 Jun 2009 14:25:00 GMT

找出两个迷宫的出口，然后分别进行dfs，求出到每一个点的最短距离。
然后对每一个点，求到最短的那个出口的距离，然后再求这个值的最大值即可。
找出口写得比较繁琐。

#include <iostream>
#include <fstream>
#include <queue>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

char maze[2*100+1][2*38+1];

bool visited[100][38];

int shortest1[100][38];
int shortest2[100][38];

bool get_first;
int exit1r,exit1c;
int exit2r,exit2c;
int w,h;

struct queue_node{
    int i,j,depth;
    queue_node(int i,int j,int depth){
        this->i = i;
        this->j = j;
        this->depth = depth;
    }
};

void bfs(int i,int j,int shortest[100][38])
{
    queue<queue_node>q;

    q.push(queue_node(i,j,1));

    while(!q.empty()){

        queue_node node = q.front();
        q.pop();

        if(visited[node.i][node.j])
            continue;

        visited[node.i][node.j] = true;

        shortest[node.i][node.j] = node.depth;

        if(node.i!=0&&maze[2*node.i][2*node.j+1]==' '){
            q.push(queue_node(node.i-1,node.j,node.depth+1));
        }
        if(node.i!=h-1&&maze[2*node.i+2][2*node.j+1]==' '){
            q.push(queue_node(node.i+1,node.j,node.depth+1));
        }
        if(node.j!=0&&maze[2*node.i+1][2*node.j]==' '){
            q.push(queue_node(node.i,node.j-1,node.depth+1));
        }
        if(node.j!=w-1&&maze[2*node.i+1][2*node.j+2]==' '){
            q.push(queue_node(node.i,node.j+1,node.depth+1));
        }
    }
}

void solve()
{
    in>>w>>h;

    for(int i=0;i<2*h+1;++i)
        for(int j=0;j<2*w+1;++j){

            do{
            in.get(maze[i][j]);
            }while(maze[i][j]=='\n');

            if((i==0||i==2*h||j==0||j==2*w)&&maze[i][j]==' '){
                if(!get_first){
                    if(i==2*h)
                        exit1r = h-1;
                    else
                        exit1r = i/2;
                    if(j==2*w)
                        exit1c = w-1;
                    else
                        exit1c = j/2;
                    get_first = true;
                }else{
                    if(i==2*h)
                        exit2r = h-1;
                    else
                        exit2r = i/2;
                    if(j==2*w)
                        exit2c = w-1;
                    else
                        exit2c = j/2;
                }
            }
        }

    memset(visited,0,sizeof(visited));
    bfs(exit1r,exit1c,shortest1);
    memset(visited,0,sizeof(visited));
    bfs(exit2r,exit2c,shortest2);

    int res = INT_MIN;

    for(int i=0;i<h;++i)
     for(int j=0;j<w;++j){
         res = max(res, min(shortest1[i][j],shortest2[i][j]) );
     }

    out<<res<<endl;
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-26 22:25 发表评论

USACO 2.4 The Tamworth Two

YZY — Fri, 26 Jun 2009 12:48:00 GMT

模拟题。按题目要求编码即可，每过一分钟，更新一下农夫和奶牛的状态。如果该状态以前出现过，说明有循环，不可能到达，输出0.

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

char grid[10][10];

bool visited[10][10][4][10][10][4];

int north = 0;
int east = 1;
int south = 2;
int west = 3;

//方向为0,1,2,3时向前走一步row和column的增加值
int delr[4] = {
    -1,0,1,0
};
int delc[4] = {
    0,1,0,-1
};

// farmer的当前row,column,direction.
int fc,fr,fd;
int cc,cr,cd;

bool available(int i,int j)
{
    if(i>=0&&i<=9&&j>=0&&j<=9&&grid[i][j]!='*')
        return true;
    else
        return false;
}

void one_step()
{
    if( available( fr+delr[fd],fc+delc[fd] ) ){
        fr += delr[fd];
        fc += delc[fd];
    }else{
        fd+=1;
        fd%=4;
    }

    if( available( cr+delr[cd],cc+delc[cd] ) ){
        cr += delr[cd];
        cc += delc[cd];
    }else{
        cd+=1;
        cd%=4;
    }
}

void solve()
{
    for(int i=0;i<10;++i)
        for(int j=0;j<10;++j){
            in>>grid[i][j];
            if(grid[i][j]=='F')
                fr=i,fc=j,fd=0;
            if(grid[i][j]=='C')
                cr=i,cc=j,cd=0;
        }

    memset(visited,0,sizeof(visited));

    visited[fc][fr][fd][cc][cr][cd] = true;

    int res = 0;

    while(true){

        one_step();
        res++;

        if( fc==cc&&fr==cr ){
            out<<res<<endl;
            exit(0);
        }

        if(visited[fc][fr][fd][cc][cr][cd]){
            out<<0<<endl;
            exit(0);
        }

        visited[fc][fr][fd][cc][cr][cd]=true;
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-26 20:48 发表评论

USACO 2.3 Controlling Companies

YZY — Fri, 26 Jun 2009 12:01:00 GMT

每加一个新结点，更新一下对各公司控制值,递归地加入新控制的结点即可。用一个布尔向量记录一下已经控制的公司，以免无穷递归。

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int stock[101][101];
int n;
bool control[101];

void add_control(int cr,int ce)
{
    if(control[ce]) return;

    control[ce] = true;
    for(int i = 1; i<=100; ++i){
        if(i!=cr&&!control[i]){
            stock[cr][i]+=stock[ce][i];

            if(stock[cr][i]>50)
                add_control(cr,i);
        }
    }
}

void solve()
{
    memset(stock,0,sizeof(stock));

    in>>n;

    int i,j,p;

    while(n--){
        in>>i>>j>>p;
        stock[i][j] = p;
    }


   for(int i=1;i<=100;++i){

       memset(control,0,sizeof(control));

       for(int j=1;j<=100;++j){

           if(i==j) continue;

           if( stock[i][j]>50){
               add_control(i,j);
           }
       }

       for(int j=1;j<=100;++j){
           if(control[j]){
               out<<i<<' '<<j<<endl;
           }
       }
   }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-26 20:01 发表评论

USACO 2.3 Money Systems

YZY — Thu, 25 Jun 2009 14:16:00 GMT

摘要: 动态规划经典题阅读全文

YZY 2009-06-25 22:16 发表评论

USACO 2.3 Zero Sum

YZY — Wed, 24 Jun 2009 13:35:00 GMT

摘要: 简单的回溯题阅读全文

YZY 2009-06-24 21:35 发表评论

USACO 2.3 Cow Pedigrees

YZY — Wed, 24 Jun 2009 12:55:00 GMT

摘要: memoization dp, 树的计数阅读全文

YZY 2009-06-24 20:55 发表评论

USACO 2.3 Longest Prefix

YZY — Tue, 23 Jun 2009 13:13:00 GMT

摘要: Trie树+简单DP 阅读全文

YZY 2009-06-23 21:13 发表评论

USACO 2.2 Runaround Numbers

YZY — Sat, 20 Jun 2009 14:35:00 GMT

生成所有长度小于9的排列数，然后判断是否为runaround数且大于m，输出第一个大于m的直接exit即可。
因为9! = 362880，数据较小，不会超时。

#include <iostream>
#include <fstream>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

int m;
bool mark[10];
int figures[10];

void solve();
void permutation(int max_dep);
unsigned long get_value(int len);
bool isok(int len);

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

void solve()
{
    in>>m;

    int start = 0;
    int tmp = m;
    while(tmp){
        tmp/=10;
        start++;
    }

    for(int i=start;i<=9;++i){
        permutation(i);
    }
}

void _permutation(int depth,int max_dep)
{
    if(depth==max_dep){
      if(isok(max_dep)){
/*        for(int i=0;i            cout<        cout<  */       unsigned long t = get_value(max_dep);

            if(t>m){
                out<<t<<endl;
                exit(0);
            }
        }
        return;
    }

    for(int i=1;i<=9;++i){
        if(!mark[i]){
            mark[i] = true;
            figures[depth] = i;
            _permutation(depth+1,max_dep);
            mark[i] = false;
        }
    }
}

//生成长度为len的全排列
void permutation(int len)
{
    memset(mark,0,sizeof(mark));
    _permutation(0,len);
}

//是runaround数
bool isok(int len)
{
    int unvisited = len;
    bool mark[10];
    memset(mark,0,sizeof(mark));

    int i = 0;
    while(unvisited--){
       i+=figures[i]; i%=(len);
       if(mark[i]) return false;
       mark[i] = true;
    }
    return true;
}

//将数组转化成unsigned long
unsigned long get_value(int len)
{
    unsigned long res = 0;
    for(int i=0;i<len;++i){
        res*=10;
        res+=figures[i];
    }

    return res;
}

YZY 2009-06-20 22:35 发表评论

USACO 2.2 Party Lamps

YZY — Sat, 20 Jun 2009 12:33:00 GMT

关键在于发现几个规律：
某一按钮，按偶数次等同于没按。
按钮的先后次序不影响结果。
灯的状态6位一组不变(解题时没发现这个规律，开了个100大小的bool数组)

剩下就是几个操作的排列组合了。代码写得很繁...

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

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

#ifdef _DEBUG
#define out cout
#define in cin
#else
#define out fout
#define in fin
#endif

struct state_node{
    bool states[101];
    int len;
    bool operator<(const state_node & n1) const{
        for(int i=1;i<=len;++i){
            if(states[i]!=n1.states[i])
                return states[i]<n1.states[i];
        }
        return false;
    }
    bool operator==(const state_node & n1) const{
        for(int i=1;i<=len;++i){
            if(states[i]!=n1.states[i])
                return false;
        }
        return true;
    }
};

state_node node;

int n,c;
vector<int>finalon,finaloff;

vector<state_node> result;

void op(int kind)
{
    switch(kind){
        case 1:
            for(int i=1;i<=n;++i)
                 node.states[i]=!node.states[i];
            break;
        case 2:
            for(int i=1;i<=n;++i){
                if(i&1)
                    node.states[i]=!node.states[i];
            }
            break;
        case 3:
            for(int i=1;i<=n;++i){
                if(!(i&1))
                    node.states[i]=!node.states[i];
            }
            break;
        case 4:
            for(int i=1;i<=n;++i){
                if(i%3==1){
                    node.states[i]=!node.states[i];
                }
            }
            break;
    }
}

bool isok()
{
    for(int i=0;i<finalon.size();++i){
        if(!node.states[finalon[i]])
            return false;
    }
    for(int i=0;i<finaloff.size();++i){
        if(node.states[finaloff[i]])
            return false;
    }
    return true;
}

void do0()
{
    if(isok())
        result.push_back(node);
}

void do1()
{
    for(int i=1;i<=4;++i){
        op(i);
        if(isok()){
            result.push_back(node);
        }
        op(i);
    }
}

void do2()
{
    for(int i=1;i<=3;++i){
        for(int j=i+1;j<=4;++j){
            op(i);
            op(j);
            if(isok()){
                result.push_back(node);
            }
            op(i);
            op(j);

        }
    }
}

void do3()
{
    //操作1,2,3,4各执行一次，前三个操作抵消
    op(4);
    do1();
}

void do4()
{
    op(4);
    if(isok()){
        result.push_back(node);
    }
    op(4);
}

void action(int i)
{
    switch(i){
        case 0: do0();break;
        case 1: do1();break;
        case 2: do2();break;
        case 3: do3();break;
        case 4: do4();break;
    }
}

void solve()
{
    in>>n>>c;

    node.len = n;

    for(int i=1;i<=n;++i)
        node.states[i] = true;

    int t;
    do{
        in>>t;
        if(t!=-1)
            finalon.push_back(t);
    }while(t!=-1);

     do{
        in>>t;
        if(t!=-1)
            finaloff.push_back(t);
    }while(t!=-1);

    bool has_result = false;

    for(int i=0;i<=4;++i){
        if(c>=i&&(c-i)%2==0){
            action(i);
        }
    }

    sort(result.begin(),result.end());
    vector<state_node>::iterator end =
        unique(result.begin(),result.end());

    for(vector<state_node>::iterator i = result.begin();
            i!=end; ++i){
        has_result = true;
        for(int j=1;j<=n;++j){
            out<<i->states[j];
        }
        out<<endl;
    }

    if(!has_result){
        out<<"IMPOSSIBLE"<<endl;
    }
}

int main(int argc,char *argv[])
{
    solve();
    return 0;
}

YZY 2009-06-20 20:33 发表评论