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

SRM 444

YZY — Wed, 08 Jul 2009 13:29:00 GMT

又在第一题上花了很多时间，这次更夸张。。用了20多分钟。。。最后提交时只有150分了。。
第二题，一看挺简单，就是求质因数的个数，然后看能被4的几次幂整除。
一开始匆忙写了一个，然后提交，400分。
代码如下：

              int getLevel(long long N)
                  {

                  int res = 0;

                  for(long long i=2;i*i<=N;++i){
                           while(N%i==0){
                                         res++;
                                         N/=i;
                                         }
                           }

                  int r=0;
                  while(res/4!=0){
                                  res/=4;
                                  r++;
                   }

                  return r;
                  }

后来一看，i*i<=N这时，N一直在变，应该保存下N或者直接求sqrt(N)。一开始不太确定sqrt能否处理long long，因此用相乘的方法。后来cha人的时候，发现一个也犯了同样的错误，马上构造56=2*2*2*7,cha掉
于是改成下面，提交，只有299分了。。。

              int getLevel(long long N)
                  {

                  int res = 0;
                  long long T = N; //增加这一行
                  for(long long i=2;i*i<=T;++i){
                           while(N%i==0){
                                         res++;
                                         N/=i;
                                         }
                   }

                  int r=0;
                  while(res/4!=0){
                                  res/=4;
                                  r++;
                   }

                  return r;
                  }

结果还是被cha掉了。因为犯了一个严重的错误，没有算上最后一个质因数，这个质因数可能大于sqrt(N)。如88==2*2*2*11。
正确代码应该是

              int getLevel(long long N)
                  {

                  int res = 0;
                  long long T = N;
                  for(long long i=2;i*i<=T;++i){
                           while(N%i==0){
                                         res++;
                                         N/=i;
                                         }
                   }

                   if(N!=1) res++; //增加这一行

                  int r=0;
                  while(res/4!=0){
                                  res/=4;
                                  r++;
                   }

                  return r;
                  }

最后房间只有一人过了第二题。
还好cha了4个，不然rating要跌不少了。。
还好rating还是涨了一点点。。
太粗心了，不然就应该能进div1了。。

YZY 2009-07-08 21:29 发表评论

SRM 443

YZY — Wed, 24 Jun 2009 03:16:00 GMT

今天Div2前两题太简单了.可惜读第一题题目时间太长,花了12分钟才提交.第二题应该是做过最简单的Div2 Mid了.直接判断有多少个圆,使得两点分别在圆内和圆外就可以了.也花12分钟提交,速度上还是太慢了.
不过是有史最快的一次Div2 Mid了.最后room第4,div136.rating小涨了一点点.但要想脱离Div2看来还得几次比赛了.

YZY 2009-06-24 11:16 发表评论

MaximumPalindromeScore (有道难题复赛400)

YZY — Mon, 22 Jun 2009 12:42:00 GMT

比赛时候没做出来，现在无法系统测试，算法看起来似乎是没问题的。

简要思想就是一层层生成所有子串，然后计算这些子串转换成同一字符串所需要的最小转换次数。
用函数min_to_make_equal来生成：将一个vector中的所有字符串转换成同一个字符串，所需要改变的最小字符数。对于last数组中的每一个字符串，将这个字符串分两半，后半部翻转。计算这些字符串转换成同一个字符串所需要的最小改变次数，如果这个次数小于等于m，说明我们可以在m次将它变成回文。计数加1。
注意如果字符串长度为奇数，我们还要先计算一下将每个中间字符变成统一字符所需要的转换次数，用m减去它。

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

using namespace std;

int cnt[51][26];

   class MaximumPalindromeScore
              {
              public:
              int maximize(string word, int m)
                  {

                  vector<string>last;
                  last.push_back(word);

                  int res = 0;

                  int i;

                  while(true){

                      //如果是串的长度为奇数，m减去"将中间字符变成统一字符需要的转换次数"
                      if(last[0].size()%2==1){
                          vector<string> mid;
                          for(i=0;i<last.size();++i){
                            mid.push_back(string(1,last[i][last[i].size()/2]));
                          }
                          m-=min_to_make_equal(mid);
                      }

                      vector<string> tmp;

                      //将每个字符串分割成两个子串，前半部不变，后半部翻转
                      //如果在这一层次上仍满足回文性质，则这些字符串应该能够转换成相同的字符串
                      for(i=0;i<last.size();++i){
                          int n = last[i].size();
                        string s1 = last[i].substr(0,n/2);
                        string s2 = last[i].substr(n-n/2,n/2);
                        reverse(s2.begin(),s2.end());
                        tmp.push_back(s1);
                        tmp.push_back(s2);
                      }

                      if(min_to_make_equal(tmp)<=m)
                          res++;
                      else
                           break;

                      //长度为奇数，不需要再计算下去了。
                      if(last[0].size()%2==1) break;

                      last = tmp;

                        }
                    return res;
                  }



              int min_to_make_equal(vector<string> &vs){
                   memset(cnt,0,sizeof(cnt));

                   int i,j;

                   for(i=0;i<vs[0].size();++i)
                       for(j=0;j<vs.size();++j)
                           cnt[i][vs[j][i]-'a']++;

                   vector<char> equal;

                   for(i=0;i<vs[0].size();++i){
                       int max = 0;
                       for(j=0;j<26;++j){
                           if(cnt[i][j]>cnt[i][max])
                               max = j;
                       }
                       equal.push_back('a'+max);
                   }

                   int res = 0;

                   for(i=0;i<vs.size();++i){
                       for(j=0;j<vs[i].size();++j){
                        if(vs[i][j]!=equal[j])
                            res++;
                       }
                   }

                   return res;
              }
};

附原题：

“回文分数”游戏并不简单。游戏的目标是修改最多maxChanges个字符使得一个字符串word的回文分数最高。只允许修改，不许增加或者删除字
符。一个字符串的回文分数定义如下：
如果字符串不是回文串，则分数为0。
如果字符串是回文串，且长度为奇数，则分数为1。
如果字符串是回文串，且长度为偶数，我们将它分为左右两半。计算它的一半子串的回文分数为K（两个一半子串得分一定相同），则原字符串的回文分数为K
+ 1。
给定一个字符串word和一个型整数maxChanges，返回最多修改maxChanges个字符后最大可能的回文分数。

DEFINITION
Class:MaximumPalindromeScore
Method:maximize
Parameters:String, int
Returns:int
Method signature:int maximize(String word, int maxChanges)


NOTES
-回文串的定义是一个字符串从前向后读和从后向前读完全一样。


CONSTRAINTS
-word包含1到50个字符（含1和50）。
-word 只包含小写字母 ('a'-'z')。
-maxChanges 取值范围是0到50（含0和50）。


EXAMPLES

0)
"coder"
2

Returns: 1

我们可以把c改成r，把e改成o，得到"rodor"。这是一个奇数长度的回文串，所以得分为1。

1)
"abcbxabcba"
1

Returns: 2

如果把x改成a，得到偶数长度的回文串"abcbaabcba"。它的一半子串是奇数长度的回文串"abcba"，所以子串分数为K = 1，因而最后
得分是K + 1 = 2。

2)
"abcdefghijklmnop"
15

Returns: 5

可以把这个字符串修改成"aaaaaaaaaaaaaaaa"、"eeeeeeeeeeeeeeee"或其他14种串，回文得分均为5。

3)
"ssssssssssssssss"
15

Returns: 5

有时不做所有允许的改变可能更好。

4)
"vyyvvzzvvxxvvxxv"
4

Returns: 3



5)
"a"
0

Returns: 1

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

TheLuckyString　(SRM 428 Div2 500)

YZY — Sun, 21 Jun 2009 03:35:00 GMT

回溯生成所有的LuckyString，计数即可。10!*26操作数。在tc上不会超时。
看Summary中很多人用next_permutation生成所有全排列再判断是否为LuckyString，这样更快更方便一些。

   class TheLuckyString
              {
              public:
                  int len;
                  int res;
                  int cnt[26];
                  int last;
                  int visited[11];
              int count(string s)
                  {
                        memset(cnt,0,sizeof(cnt));

                        len = s.size();
                        res = 0;

                        for(int i=0;i<s.size();++i)
                            cnt[s[i]-'a']++;

                        int len = s.size();

                        bt();

                        return res;

                        return 0;
                  }

              void bt(){
                  for(int i=0;i<26;++i){
                      if(cnt[i]!=0){
                          visited[0]=i;
                          cnt[i]--;
                          _bt(1);
                          cnt[i]++;
                      }
                  }
              }

              void _bt(int depth){
                  if(depth==len){
                    res++;
                    return;
                  }
                      for(int i=0;i<26;++i){
                          if(cnt[i]!=0){
                              if(i==visited[depth-1])
                                  continue;
                            visited[depth] = i;
                            cnt[i]--;
                            _bt(depth+1);
                            cnt[i]++;
                          }
                      }
              }
｝

next_permutation解：

   class TheLuckyString
              {
              public:
              int count(string s)
                  {

                  int res = 0;

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

                  do{
                      bool ok = true;
                      for(int i=0;i+1<s.size();++i){
                          if(s[i]==s[i+1]){
                              ok = false;
                              break;
                          }
                      }

                      if(ok)
                        res++;

                  }while( next_permutation(s.begin(),s.end()) );

                    return res;
                  }
              }

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

SubrectanglesOfTable (SRM 429 Div2 500)

YZY — Sun, 21 Jun 2009 03:26:00 GMT

这题看了别人讨论才做出来。

暴力法：枚举所有的矩形，然后统计各个矩形中的字符数。这样时间复杂度O(n^12)必然超时。

可以反过来考虑问题，对于矩形中的每一个单元，会有多少个矩形包含它。

这样思考，问题就很简单了：
一个矩形可以由它的左上角和右下角唯一决定。
而若某单元(x,y)包括在某矩形中，那么，这个矩形的左上角(x',y')必然为(0<=x'<=x),(0<=y'<=y).
右上角(x'',y'')必然为(x<=x''这样的矩形显然有(x+1)(y+1)(c-x)(c-y)个。(坐标均为0-based)

代码如下：

   class SubrectanglesOfTable
              {
              public:
              vector<long long> getQuantity(vector <string> t)
                  {
                          vector<long long> res(26);

                          for(int i=0;i<t.size();++i)
                               t[i]+=t[i];

                          int tmp = t.size();
                          for(int i=0;i<tmp;++i)
                            t.push_back(t[i]);

                          int r = t.size();
                          int c = t[0].size();

                          for(int i=0;i<r;++i)
                             for(int j=0;j<c;++j){
                                  res[ t[i][j]-'A']+=(i+1)*(j+1)*(r-i)*(c-j);
                                  }

                          return res;
                  }
　　　　　　　｝

其实不需要生成字符串的四个拷贝。

YZY 2009-06-21 11:26 发表评论

BitwiseEquations (SRM 430 Div2 500)

YZY — Sat, 20 Jun 2009 04:02:00 GMT

题目链接：http://www.topcoder.com/stat?c=problem_statement&pm=9921&rd=13521

x+y=x|y.
二进制加法1+0=1|0.　当而仅当x,y的二进制表示中，x的'1'位不与y的'1'对应，这个等式就成立．
所以，对于x中为1的位，y只能为0，对于x中为0的位，y相应位可以任意．
要求第k个y,很显然，把k的二进制表示填充到x的0位中去，即可．

   class BitwiseEquations
              {
              public:
              long long kthPlusOrSolution(int _x, int k)
                  {
                  long long result;
                  long long mask = 1;
                  long long x = _x;
                  result = 0;

                  for(int i=0;i<64&&k!=0;++i){
                      if((mask&x)==0){
                            result|=((k&1)*mask);
                            k>>=1;
                      }
                      mask<<=1;
                  }
                  return result;
              }
}

YZY 2009-06-20 12:02 发表评论

LampGrid (SRM 432 Div2 500)

YZY — Mon, 08 Jun 2009 14:51:00 GMT

题目链接：http://www.topcoder.com/stat?c=problem_statement&pm=10154&rd=13694

看了解题报告才做出来，实在是太水了.T.T

关键的思路在于无论怎么开关，相同的行永远是相同的。
此外就是在某一开关上开关偶数次等于0次，开关的顺序是无关的。

对于某一行，把它变成全1所需要的操作次数为它的0的个数。
而这些操作最终导致全1的行数等于最初与这一行相同的行的行数。

用map存储一下每一行相同的行数，再看k次开关能否使其变成全1。
能使其变成全1的话，即可更新一下最大的行数了。

#include <vector>
#include <algorithm>
#include <sstream>
#include <string>
#include <iostream>
#include <map>

using namespace std;

         class LampsGrid
              {
              public:

              int mostLit(vector <string> initial, int K)
                  {
                      map<string,int> cnt;

                      for(int i=0;i<initial.size();++i){
                          cnt[initial[i]]++;
                      }

                      int res = 0;

                      for(map<string,int>::iterator i = cnt.begin();
                              i!=cnt.end();
                              ++i){

                          int num_0 = count(i->first.begin(),i->first.end(),'0');

                          if( (K>=num_0) && (K-num_0)%2==0 ){
                              res = max(res,cnt[i->first]);
                          }
                      }

                      return res;
                  }
}

YZY 2009-06-08 22:51 发表评论

MagicWords (SRM433 Div2 500)

YZY — Mon, 08 Jun 2009 12:38:00 GMT

题目链接：http://www.topcoder.com/stat?c=problem_statement&pm=10195

直接按描述生成S的所有排列，并计数就可以了。用map缓存一下计算结果，不然会超时
在一个整数vector上用next_permutation算法来生成所有排列的索引。

#include <vector>
#include <algorithm>
#include <sstream>
#include <string>
#include <iostream>
#include <map>

using namespace std;

         class MagicWords
              {
              public:

               map<string,bool> m;

              int count(vector <string> s, int k)
                  {
                      int ret = 0;

                      vector<int> v(s.size());

                      for(int i=0;i<v.size();++i)
                          v[i] = i;

                      m.clear();

                      do{

                          string str;
                          for(int i=0;i<v.size();++i){
                              str+=s[v[i]];
                          }
                          if( isMagic(str,k) )
                              ret++;

                      }while( next_permutation(v.begin(),v.end()) );

                      return ret;
                  }

              bool isMagic(string &str,int k){

                  if(m.find(str)!=m.end())
                      return m[str];

                  int cnt = 1;
                  int len = str.size();
                  for(int i=1;i<len;++i){
                      bool ok = true;
                      for(int j=0;j<len;++j){
                          if( str[j] != str[(j+i)%len]){
                              ok = false;
                              break;
                          }
                      }

                      if(ok)
                       cnt++;
                  }

                  m[str] =  (cnt==k);

                  return cnt==k;
              }
}

YZY 2009-06-08 20:38 发表评论

The Swap (SRM 437 Div2 500)

YZY — Fri, 05 Jun 2009 14:53:00 GMT

题目链接：http://www.topcoder.com/stat?c=problem_statement&pm=10369&rd=13699
一开始想贪心＋递归做。。。始终fail systemtest。。
贪心无法证明，还是用dp了。

若用递推，复杂度为O(10^6*10*50)=O(5*10^8)，应该会超时。。可能在tc的牛机上不会超。。。
用memoization的dp就不会超了,因为大部分状态是不会到达的。

#include <algorithm>
#include <sstream>
#include <string>
#include <iostream>

//44M内存。。。空间不会超
int dp[1000001][11];

using namespace std;

         class TheSwap
              {
              public:

              int findMax(int n, int k)
                  {

                     // memset -1 从语义上说是不对的，只是-1为全1，4个byte恰好拼成一个int时还是-1
                      memset(dp,-1,sizeof(dp));

                     //将n转化成字符串。貌似gcc不支持itoa函数,不是标准函数
                      stringstream ss;
                      ss<<n;
                      string s;
                      ss>>s;

                      return _findMax(s,k);

                  }

                  int _findMax(string &s,int k){

                      int n = atoi(s.c_str());

                      if(k==0)
                          return n;

                      if(dp[n][k]!=-1)
                          return dp[n][k];

                      for(int i=0;i<s.size();++i){
                          for(int j=i+1;j<s.size();++j){
                              if(s[j]=='0'&&i==0){
                                  // invalid
                                  continue;
                              }
                              swap(s[i],s[j]);
                              dp[n][k] = max(dp[n][k],_findMax(s,k-1));
                              swap(s[i],s[j]);
                          }
                      }

                     return dp[n][k];
                  }

YZY 2009-06-05 22:53 发表评论

FeudaliasBattle (SRM438 Div2 500)

YZY — Fri, 05 Jun 2009 11:39:00 GMT

题目很简单，只是在计算的细节上在计算导弹和目标的距离的时候，用int型可能会溢出，要转换成double再计算。
希望以后不要再犯这样的错误了，sigh.

YZY 2009-06-05 19:39 发表评论

PouringWater (SRM 439 Div2 500)

YZY — Wed, 03 Jun 2009 12:31:00 GMT

题目链接：http://www.topcoder.com/stat?c=problem_statement&pm=10408&rd=13747

最终的水要放在K个瓶子里面，而每个瓶子中的水的数量必须为2的整数幂，即最终的水数量n'要能分解成
k个2的整数幂，也就是new_n的二进制表示中1的个数要<=k.

用count(n)表示n的二进制表示中1的个数，如果count(n)<=k，那就不需要买瓶子了。
如果count(n)>k，说明我们要找到第一个n'使得n'>n并且count(n')<=k。那就是说我们要减少n中1的个数。
我们把n表示为x0ab.其中a为全1,b为全0. a,b的长度>=0.
很明显，第一个减少1的个数的n'应该为x1{(a+b)个0}，也就是把ab全部变成0.ab前的0变为1.即加上一个1<因为对b来说，无论增加多少都会增加1的个数。
然后再判断n'的1的个数，直到count(n)<=k。
因为n最大为10^7，n'最大为10^8，int类型不会溢出。因此边界条件就无需判断了。

1 #include <vector>
2 #include <algorithm>
3 #include <sstream>
4 #include <string>
5 #include <iostream>
6
7 using namespace std;
8
9 int count(int i)
10 {
11     int res = 0;
12     while(i!=0){
13         i&=(i-1);
14         res++;
15     }
16
17     return res;
18 }
19
20          class PouringWater
21               {
22               public:
23               int getMinBottles(int N, int K)
24                   {
25                       int res = 0;
26                       int mask = 1;
27
28                       while(count(N)>K){

29                            //找到第一个1...第n次犯了没把N&mask括号括起来的错误了。。。&的优先级<等号...
30                           while( (N&mask)==0) mask<<=1;

31 //加上mask使得1的数目减少
32                           N+=mask;
33                           res += mask;
34                       }
35
36                       return res;
37                   }
38
39

YZY 2009-06-03 20:31 发表评论