C++博客-昨夜西风凋碧树，独上高楼，望尽天涯路！-随笔分类-ACM题解

线段树系列之--求N个矩形面积并(PKU 3277)

小果子 — Mon, 09 Mar 2009 06:27:00 GMT

摘要: //回忆系列://可以优化的，去除重复点，我这没这一步，而且我比较懒，直接把离散这一步省略了，直接替代了//不过离散化+线段树思想是不变的,注释比较少 1//segment tree template 2#include 3#include 阅读全文

小果子 2009-03-09 14:27 发表评论

线段树系列之----单点更新,区间最大(HDU 1754)

小果子 — Sun, 08 Mar 2009 07:35:00 GMT

摘要: //回忆系列.. 1//segment tree template 2#include 3 4using namespace std; 5struct Tnode{ 6&... 阅读全文

小果子 2009-03-08 15:35 发表评论

第33rd ACM/ICPC 亚洲区杭州赛区总结 (夜深的时候，也是最清净的时候^_^)

小果子 — Fri, 05 Dec 2008 17:12:00 GMT

夜深的时候，也是最清净的时候:

比赛已经过去二个星期了，因为比完后一直比较忙，所以把总结的事给忘了，不过今天看到队友写了篇，还是自己也写一下，毕竟可能是自己最后一场值得自己回忆的比赛了.

应该说我们队的实力还是有的，还是没有发挥到极致，当然作为队长的我，有很大责任，暑假一直训练下来后，渐渐的，比赛中，基本是我感觉能应付的题目我来写，jy和cyy更喜欢讨论后一起写，于是渐渐的，比赛时，也养成了这习惯..当题目实在没法时，三人会一起讨论，集中写某一题。集训开始时状态还是很好的，不过随着时间的过去，我们队的整个状态不是很好，集训队内部比赛比的比较差，不过那时刚配合，彼此之间真的缺少认识，随着一场一场比赛下来，彼此间也有很多认识，默契也渐渐形成.不过配合还是不稳定，时好时坏.

不过杭州赛区现场赛之前的两三场练习赛，我感觉自己状态还是很好的，虽然那时题目基本没怎么练，但是每个星期的练习赛慢慢的把我自己的状态往好处调整.本来lcy让我们参加北京站的，不过那时估计整个队的状态不是太稳定吧，所以还是把我们安排了在自己学校比，这也为我们积攒了N多RP..我想老师的安排还是十分合理的，因为那时的我们队状态确实不是很稳定，而且自己信心也不是很足。要是参加北京站的话，可能在自己学校比的成绩可能就不像现在了。所以为自己和自己队调整状态留了两个星期左右的时间。老实说，自己学校比确实压力比较大，不过比赛时心态还是比较好的。后话了

比赛前一星期吧，手机也莫名坏了，电话一大过来，我手机就自动重启，也不知道谁打过来，在此，向打电话给我的朋友们说声sorry.短信也不能收发，把我郁闷的够呛。变成了“单向”手机了基本，只能我给别人打电话。呵呵。无形中也为比赛积攒了RP比赛前的那个星期五，六，大家都很忙，因为比赛在即，有许多事要做。大家一起帮忙搞机器和测试机器。真的感谢HDUAcmers他们。真的。他们付出了许多为这次比赛。还有lcy

比赛前的最后二场热身赛，自己状态感觉很好。不过唯一不好的是自己得了感冒。不过我感冒从来不吃药的，但是还是把我弄的比较难受..不过基本没怎么受影响，除了比赛中让我多跑了几趟洗手间.^_^.比赛前的热身赛题目，做的也比较容易，3题也算轻松搞定。呵呵。只=正式比赛开始。。

正赛赛随着一声大锣声敲响比赛终于开始，整场比赛五个小时，应该说自己心态保持的还是很好，注意力也是比较集中。
这次杭州站。聚集了N多牛队.其中有”梦之队“美誉的清华lct那之队备受关注。因为lct的参加，同时杭州赛区也是参加队伍最多的一站比赛，所以杭州赛区也备受关注.

比赛开始后.还是向以前一样，我看中间，cyy看前面，jy看后面，题目总共10题，大概20多分钟后，赛场里就有气球飘起来了。最多的是A题，cyy看完后也有想法，上去敲。。我还是看中间的，其中一题是计算几何的（这题也是这次比赛最遗憾的一题），不多久，J题也过的比较多，那时cyy写了一会遇到了写麻烦，于是cyy和jy一起讨论，我看J题，我看了J题后，第一感觉是并查集，不过不完全是，不过想法还是有了。只=cyy和jy两个把A敲完，我在纸上重新整了下思路，没多久，A题敲完了，提交，我马上上去敲J题，A题没多久返回YES，很开心，毕竟开了一个好头，于是我敲起了J题，
很快敲完，但是sample没过，打印，我看了下代码，和输出的东西，我忘了一个欠考虑的东西了。虽然也可以实现，但是时间复杂度明显和我预期的差了好多，估计会爆掉。因为这时J题过了比较多，其他的过的比较少，他们俩也无题可做，于是三个一起做了J题，不过还是想往常一样，cyy和jy讨论他们的解法，我还是想着我自己的那方法，不过并查集方法还是没变，不久，几乎同时，我想出了我的方法，cyy和jy也想出了他们的方法，我说给我10分钟就好，不过cyy抢着要，反正写起来很快，那时比赛还不到一个半小时，所以时间还很多，不急，于是主动让出机子，他们写，为了以防万一他们返回wa,我也在纸上写了起来，按我自己的方法写了起来，这样比较保险，毕竟两个不同的方法，不过这时，鼻子
难受的让我不得不去洗手间，于是趁他们写时我上了一趟洗手间，回来后再纸上写了起来，过了20多分钟，他们写完了，我纸上也写完了，上去敲J。没多久，J返回YES，要是不是比赛的话，我肯定把自己的敲完，也交一遍了。呵呵。毕竟是比赛，只要YES就OK了。于是马上转攻其他题，这时我看了下排名，排的大概50+，要想稳拿牌的话必须在做一题，这时看了下，G题过的比较多，因为实在没啥题可写，于是三人一起看G题，G看完后，第一感觉我没想法，不过，我读了几遍后，解法慢慢浮出，而且思路也比较清晰，直接拓扑排序就好了，于是我把思路和jy说了下，jy也完全赞同，于是敲定。于是我让jy直接敲，我写纸上，那感冒又把我搞的难受死了，于是又上了趟洗手间，回来后很快写完，jy也写完，不过jy有一个地方没确定，问了我一下，我很快给出答复，因为我去洗手间过程中刚好考虑了jy这种情况，sample过后，直接提交，我接过机子，敲G，以防另一个万一,呵呵，ms人品真的爆发了一下，又返回了一个YES.三个题目都是一次y，当第三个题返回yes的时候，确实比较高兴，思路正确.于是我那纸上的代码又永存了（因为代码量不大，比完测试了下，YES，^_^)，于是看其他题去了，这是F题做的比较多，就是我起初看的那题计算几何的，其实这题不是很难，但是实现起来比较麻烦，我按半径枚举在按极角枚举，感觉方法没错，复杂度也是可接受范围，但是实现起来却很麻烦，因为计算几何对自己来说写起来比较棘手，写的比较少平时，虽然时间够的话可能会慢慢磨出来，不过那时好像还剩1个半小时的左右开始写的时候，应该说时间还是比较多的留的，因为过了这题，快的话估计可以拼一下银牌，还是很犹豫的写这题，我事先和cyy和jy说了下，我不保证这题能写出来，因为自己真的对这题难以把握虽然有想法，但是实现起来很麻烦，于是写了起来，但是还是写的少的缘故，写起来很费劲，而且对最后特殊情况的处理情况和很多。于是慢慢的把自己搞的”毛“起来了，期间，cyy和jy也想了个类似的方法，于是机子一空，我们轮流着写，一直到比赛结束也没把它搞出来。应该说是这次比赛最大的遗憾了。最后，我们队拿了一块宝贵的铜牌，清华”梦之队“也如愿夺得冠军.

这次比赛，可能是自己最后一次参加acm比赛，所以显得弥足珍贵，现在马上跨入大三下半学期，不知道自己还能否坚持。不过自己对acm还是不会放弃的，因为它，我才认识了许许多多的好朋友,让我学到了很多..真的感谢acm,感谢lcy老师，自己觉得有点对不住老师，因为我感觉自己还是可以更好的，拿更好的成绩回报老师，但是事事并不如愿（我自己的一些原因）吧，在这向lcy老师道声歉，老师，感谢你，真的从心底感谢一路陪我走过的HDU Acmers。不忘大家..

最后，祝愿HDU-ACM明天会更好.也祝愿一路走过的伙伴们一路顺风祝福考研的师哥师姐们，加油

小果子 2008-12-06 01:12 发表评论

最大团题

小果子 — Thu, 31 Jul 2008 05:03:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1530(赤裸裸的最大团)
http://acm.pku.edu.cn/JudgeOnline/problem?id=1419

pku1419解析:
本题是给定一个无向图G,对顶点进行染色（0，1），使相邻的两个点不同时为1(黑色),因为n>=100,直接暴搜的话复杂度为2^100,(据说也能过，未尝试),换思路，因为相邻的点不能同时为1，所以只要找出最大的一个集合，使该集合内的点都没有边，集合内点的个数就是答案,就是求最大独立集...而最大独立集=G' 的最大团...所以转化为求最大团......

小果子 2008-07-31 13:03 发表评论

zoj3008(月赛)

小果子 — Mon, 28 Jul 2008 12:58:00 GMT

http://acm.zju.edu.cn/show_problem.php?pid=3008

 1 #include <iostream>
 2 #include <vector>
 3 #include <cmath>
 4 
 5 using namespace std;
 6 class Num
 7 {
 8 public:
 9     void factorization(){
10         //n==1特殊处理
11 
12         //
13         //n>1
14         int i=0;
15         for(i=0;n%2==0&&n>1;n/=2,i++);
16         if(i>0){
17             prime.push_back(2);
18             num.push_back(i);
19         }
20 
21         int t=0,j;
22         for(i=3;i<=n;i+=2){
23               for(j=0;n%i==0&&n>1;n/=i,j++);
24               if(j>0){
25                   prime.push_back(i);
26                   num.push_back(j);
27               }
28         }
29         return;
30     }
31     Num(int x=0):n(x){
32         prime.clear();
33         num.clear();
34     }
35     vector<int> prime,num;
36     int n;
37 };
38 Num p;
39 int n,m,ans;
40 void dfs(int i,unsigned long long val)
41 {
42     unsigned long long tt=val;
43     unsigned long long t=1;
44     for(int j=0;i<p.num.size()&&j<=p.num[i]*m;j++){
45         val*=t;
46         if(val<=n&&i==p.num.size()-1){
47             ans++;
48             //return;
49         }
50         if(val<=n&&i+1<p.num.size()){
51             dfs(i+1,val);
52         }
53         if(val>n)return;
54         t*=p.prime[i];
55         val=tt;
56     }
57     return ;        
58 }
59 int main()
60 {
61     while(scanf("%d%d",&n,&m)!=EOF){
62         if(n==1){
63             printf("1\n");
64             continue;
65         }
66         ans=0;
67         p.n=n;
68         p.num.clear();
69         p.prime.clear();
70         p.factorization();
71         dfs(0,1);
72         printf("%d\n",ans);
73     }
74     return 0;
75 }

小果子 2008-07-28 20:58 发表评论

pku3681 月赛(ym)

小果子 — Mon, 28 Jul 2008 09:43:00 GMT

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <vector>
 4 
 5 using namespace std;
 6 struct Node
 7 {
 8     int xi,yi;
 9     Node(int x=0,int y=0):xi(x),yi(y){};
10 };
11 bool op1(const Node& a,const Node& b)
12 {
13     if(a.xi==b.xi)return a.yi<b.yi;
14     return a.xi<b.xi;
15 }
16 bool op2(const Node& a,const Node& b)
17 {
18     if(a.yi==b.yi)return a.xi<b.xi;
19     return a.yi<b.yi;
20 };
21 
22 int marx[10005];
23 
24 vector<Node> vecx,vecy;
25 int main()
26 {
27     int c;
28     scanf("%d",&c);
29     while(c--){
30         vecx.clear();
31         vecy.clear();
32         int n,m;
33         scanf("%d%d",&n,&m);
34         int x,y;
35         for(int i=0;i<n;i++){
36             scanf("%d%d",&x,&y);
37             Node tmp(x,y);
38             ++marx[x];
39             vecx.push_back(tmp);
40             vecy.push_back(tmp);
41         }
42 
43         sort(vecx.begin(),vecx.end(),op1);
44         sort(vecy.begin(),vecy.end(),op2);
45 
46         int ans=0x7fffffff;
47         int start=0,cnt,tt,end=0;
48         for(int i=0;i<n;++i){
49             for(int j=i;j<n;++j){
50                 start=0;
51                 end=-1;
52                 cnt=0;
53                 tt=0;
54                 for(start=0;start<n&&end<n;){
55                     if(cnt<m){
56                         end++;
57                         if(end==n)break;
58                         if(vecx[end].yi<=vecy[j].yi&&vecx[end].yi>=vecy[i].yi)cnt++;
59                     }
60                     else{
61                         if(vecx[start].yi<=vecy[j].yi&&vecx[start].yi>=vecy[i].yi){
62                             int lenx=abs(vecx[end].xi-vecx[start].xi)+2;
63                             int leny=abs(vecy[i].yi-vecy[j].yi)+2;
64                             if(lenx*leny<ans)ans=lenx*leny;
65                         }
66                         if(vecx[start].yi<=vecy[j].yi&&vecx[start].yi>=vecy[i].yi)cnt--;
67                         start++;
68                     }
69                 }
70             }
71         }
72         printf("%d\n",ans);            //start++
73     }
74     return 0;
75 }

实力不够...继续努力...

小果子 2008-07-28 17:43 发表评论

pku 1753

小果子 — Thu, 15 May 2008 12:22:00 GMT

题目意思说用最少的次数翻动使所有的面是白色或黑色:
思路:通过枚举第一行的状态（16种状态），得出答案..
附上code:

 1 #include <iostream>
 2 #include <string>
 3 #include <bitset>
 4 
 5 using namespace std;
 6 int map[10][10];
 7 int opr[10][10];
 8 int ans,zhen;
 9 void hanshu(int n)
10 {        
11     for(int i=0;i<16;i++){
12         int cnt=0;
13         bitset<4> bit(i);
14         for(int r=1;r<=4;r++)
15             for(int j=1;j<=4;j++)
16                 opr[r][j]=map[r][j];
17         for(int r=0;r<4;r++){
18             if(bit[r]==1){
19                 cnt++;
20                 opr[1][r+1]^=1;
21                 opr[1][r]^=1;
22                 opr[2][r+1]^=1;
23                 opr[1][r+2]^=1;
24             }
25         }
26         for(int r=2;r<=4;r++){
27             for(int j=1;j<=4;j++){
28                 if(opr[r-1][j]==n){
29                     cnt++;
30                     opr[r-1][j]^=1;
31                     opr[r][j-1]^=1;
32                     opr[r][j]^=1;
33                     opr[r][j+1]^=1;
34                     opr[r+1][j]^=1;
35                 }
36             }
37         }
38         bool prim=false;
39         for(int i=1;i<=4;i++){
40             if(opr[4][i]==n){
41                 prim=true;
42             }
43         }
44         if(!prim&&cnt<ans){
45             zhen=0,ans=cnt;
46         }
47     }
48 }
49 int main()
50 {
51     string ss;
52     while(cin>>ss){
53         ans=0x7fffffff;
54         zhen=-1;
55         memset(map,0,sizeof(map));
56         memset(opr,0,sizeof(opr));
57         for(int i=0;i<ss.size();++i){
58             if(ss[i]=='b')map[1][i+1]=0;
59             else map[1][i+1]=1;
60         }
61         for(int i=2;i<=4;i++){
62             cin>>ss;
63             for(int j=0;j<ss.size();j++){
64                 if(ss[j]=='b')map[i][j+1]=0;
65                 else map[i][j+1]=1;
66             }
67         }
68         hanshu(0);
69         hanshu(1);
70         if(zhen!=-1)cout<<ans<<endl;
71         else cout<<"Impossible"<<endl;
72     }
73     return 0;
74 }
75 

小果子 2008-05-15 20:22 发表评论

郁闷了一回

小果子 — Sat, 05 Apr 2008 08:21:00 GMT

今天做ural 1002，题目描述：

1002. Phone numbers

Time Limit: 2.0 second
Memory Limit: 16 MB

Background

In the present world you frequently meet a lot of call numbers and they are going to be longer and longer. You need to remember such a kind of numbers. One method to do it in an easy way is to assign letters to digits as shown in the following picture:

	1 ij	2 abc	3 def
4 gh	5 kl	6 mn
7 prs	8 tuv	9 wxy
0 oqz

This way every word or a group of words can be assigned a unique number, so you can remember words instead of call numbers. It is evident that it has its own charm if it is possible to find some simple relationship between the word and the person itself. So you can learn that the call number 941837296 of a chess playing friend of yours can be read as WHITEPAWN, and the call number 2855304 of your favourite teacher is read BULLDOG.

Problem

Write a program to find the shortest sequence of words (i.e. one having the smallest possible number of words) which corresponds to a given number and a given list of words. The correspondence is described by the picture above.

Input

Input contains a series of tests. The first line of each test contains the call number, the transcription of which you have to find. The number consists of at most 100 digits. The second line contains the total number of the words in the dictionary (maximum is 50000). Each of the remaining lines contains one word, which consists of maximally 50 small letters of the English alphabet. The total size of the input file doesn't exceed 300KB. The last line of input file contains call number -1.

Output

Each line of output contains the shortest sequence of words which has been found by your program. The words are separated by single spaces. If there is no solution to the input data, the line contains text "No solution.". If there are more solutions having the minimum number of words, you can choose any single one of them.

Sample

input	output
7325189087 5 it your reality real our 4294967296 5 it your reality real our -1	reality our No solution.

思路就是dp,状态转移是dp[i]=min(dp[i-len[j]]+1)(1<=j<=n)
code:

#include <iostream>
#include <string>
#include <algorithm>
#include <stack>
#include <vector>

using namespace std;
//#pragma comment(linker, "/STACK:16777216")

const int N=105;
const int M=50001;
int dp[N];
int pathone[N];
int pathtwo[N];
int hash[26]={2,2,2,3,3,3,4,4,1,1,5,5,6,6,0,7,0,7,7,8,8,8,9,9,9,0};
vector<string> vec,v;
vector<int> ve;
void Init()
{
    memset(dp,0,sizeof(dp));
    memset(pathone,0,sizeof(pathone));
    memset(pathtwo,0,sizeof(pathtwo));
    vec.clear();
    v.clear();
    ve.clear();
};
int main()
{
    string ss;
    while(cin>>ss){
        if(ss=="-1")break;
        Init();
        int n;
        cin>>n;
        string str;
        for(int i=0;i<n;i++){
            cin>>str;
            v.push_back(str);
            string tmp;
            for(int j=0;j<str.size();j++){
                tmp+=hash[str[j]-'a']+48;
            }
            vec.push_back(tmp);
        }
        dp[0]=1;
        for(int i=1;i<=ss.size();++i){
            for(int j=0;j<vec.size();++j){
                if(i-vec[j].size()>=0&&dp[i-vec[j].size()]>0){
                                   if(vec[j]==ss.substr(i-vec[j].size(),vec[j].size())&&(dp[i]==0||dp[i]>dp[i-vec[j].size()]+1)){
                        dp[i]=dp[i-vec[j].size()]+1;
                        pathone[i]=j;
                        pathtwo[i]=i-vec[j].size();
                    }
                }
            }
        }
        if(dp[ss.size()]==0){
            cout<<"No solution.\n";
        }
        else{
            int mm=ss.size();
            //ve.push_back(mm);
            while(mm!=0){
                //stk.push(v[pathone[mm]]);
                ve.push_back(mm);
                mm=pathtwo[mm];

            }
            for(int i=ve.size()-1;i>=0;i--){
                if(i==ve.size()-1)cout<<v[pathone[ve[i]]];
                else cout<<" "<<v[pathone[ve[i]]];
            }
            cout<<endl;
        }
    }
    return 0;
}

以上code ,(Crash), 看了FAQ,相当于STACK_OVERFLOW ,先是郁闷。。。。
玩了花了N多时间查找哪错问题了。。。。
没办法时加了句 i-vec[j].size()于是想问下各位路过大牛，，题目明显是i我碰到类似dp,用dp[i+len[j]]>dp[i]+1 dp[i+len[j]]=dp[i]+1转换下，就不会出现此问题，，而用dp[i-len[j]]+1=0&&i-len[j]

小果子 2008-04-05 16:21 发表评论