第四周 9.21---9.27

---------9.21

cf 519 e

http://codeforces.com/problemset/problem/519/E

补了之前说的要滚去学的lca

有4种情况

1.  u 是lca,v是lca,这种不合法

2.  u 是lca,v不是lca,这种要找他们的中点是不是存在

3.  u 不是lca,v是lca，和第二种一样

4. u不是lca,v不是lca ；再分两种情况，u，v到lca的距离不等，u，v到lca的距离相等

  1 #include
  2 #include
  3 #include
  4 #include
  5 #include
  6 using namespace std;
  7 
  8 const int INF = (1<<30)-1;
  9 const int maxn = 400005;
 10 const int MAX_LOG = 20;
 11 
 12 int n,m;
 13 int first[maxn],ecnt;
 14 int fa[MAX_LOG][maxn],dep[maxn];
 15 int dp[maxn],vis[maxn];
 16 int sz[maxn];
 17 
 18 struct Edge{
 19     int u,v,next,w;
 20 };
 21 
 22 Edge e[10*maxn],ea[10*maxn];
 23 
 24 void init(){
 25     ecnt  = 0;
 26     memset(first,-1,sizeof(first));
 27 }
 28 
 29 void Add_edge(int u,int v){
 30     e[ecnt].u = u;
 31     e[ecnt].v = v;
 32     e[ecnt].next = first[u];
 33     first[u] = ecnt++;
 34 }
 35 
 36 void Dfs(int p,int pre,int d){
 37     fa[0][p] = pre;
 38     dep[p] = d;
 39     sz[p] = 1;
 40     for(int i = first[p];~i;i = e[i].next){
 41         int v = e[i].v;
 42         if(v == pre) continue;
 43         Dfs(v,p,d+1);
 44         sz[p] += sz[v];
 45     }
 46 }
 47 
 48 void Pre(){
 49     Dfs(1,-1,0);
 50     for(int k = 0;k+1 < MAX_LOG;++k){
 51         for(int v = 1;v <= n;v++){
 52             if(fa[k][v] < 0) fa[k+1][v] = -1;
 53             else fa[k+1][v] = fa[k][fa[k][v]];
 54         }
 55     }
 56 }
 57 
 58 int Lca(int u,int v){
 59     if(dep[u] > dep[v]) swap(u,v);
 60     for(int k = MAX_LOG-1;k >= 0;--k){
 61         if(dep[v]-dep[u] & (1<<k))
 62         v = fa[k][v];
 63     }
 64     if(u == v) return u;
 65     for(int k = MAX_LOG-1;k >= 0;--k){
 66         if(fa[k][u] != fa[k][v]){
 67             u = fa[k][u];
 68             v = fa[k][v];
 69         }
 70     }
 71     return fa[0][u];
 72 }
 73 
 74 int Up(int d,int u){
 75     for(int k = MAX_LOG-1;k >= 0;k--){
 76         if(d & (1< fa[k][u];
 77     }
 78     return u;
 79 }
 80 
 81 void solve(int u,int v){
 82     if(u == v){
 83         printf("%d\n",n);
 84         return;
 85     }
 86     int lca = Lca(u,v);
 87     //printf("u = %d  v = %d  lca = %d\n",u,v,lca);
 88     
 89     int l = dep[u] + dep[v]-2*dep[lca];
 90         if(l%2){
 91             printf("0\n");
 92             return;
 93         }
 94     
 95     if((u == lca && v != lca) || (u != lca && v == lca)){
 96         int x = 0;
 97         if(u == lca) x = v;
 98         else x = u;
 99         
100         int y = Up(l/2,x);
101         int z = Up(l/2-1,x);
102     //    printf("x = %d  y = %d lca = %d\n",x,y,lca);
103         int res = sz[y]-sz[z];
104         printf("%d\n",res);
105     }
106     
107     if(u != lca && v != lca){
108         int l = dep[u] - dep[lca];
109         int r = dep[v] - dep[lca];
110     //    printf("u = %d v = %d  l = %d r = %d\n",u,v,l,r);
111         if(l == r){    
112             int y = Up(l-1,u);
113             int z = Up(r-1,v);
114     //        printf("===l = %d  r = %d y = %d  z = %d\n",l,r,y,z);
115             int res = n-sz[y]-sz[z];
116             printf("%d\n",res);
117         }
118         else{
119             if(dep[u] > dep[v]) swap(u,v);
120             int x = v;
121             int y = Up((l+r)/2,x);
122             int z = Up((l+r)/2-1,x);
123     //        printf("---x = %d  y = %d  z = %d\n",x,y,z);
124             int res = sz[y]-sz[z];
125             printf("%d\n",res);
126         }
127     }    
128 }
129 
130 int main(){
131     while(scanf("%d",&n) != EOF){
132         init();
133         for(int i = 1;i <= n-1;i++){
134             int u,v;
135             scanf("%d %d",&u,&v);
136             Add_edge(u,v);
137             Add_edge(v,u);
138         }
139         memset(sz,0,sizeof(sz));
140         Pre();
141         scanf("%d",&m);
142         for(int i = 1;i <= m;i++){
143             int u,v;
144             scanf("%d %d",&u,&v);
145             solve(u,v);
146         }
147     }
148     return 0;
149 }

View Code

 

不知道该说什么，做完这次的网络赛

B的模拟还不懂写，G还不懂，F想一天无果

也不算想了一天，上了一天不知道什么的专业课

晚上协会讲C语言

boss也来了

想到去年这会儿在刷计算机二级的题

前年的这会儿刚滚来学校，好像军训还没有结束，，在花样队日子过得相当滋润

那会儿我们在汽车试验场训练

练几分钟，歇几分钟

虽然很晒

可是有好大的风

教官还说那是来自渭河的风-----------------------

后来我们专业学工图

憋半天憋不出一颗螺钉-------------------------------------------------

最后交作业大图通过了简直高兴得像狗一样-------

------------------------------------------------------

扯了好远了

今晚跑步居然跑了4圈---

真是像狗一样的狂奔-------------

不说了，

最后-------------------------------------------

还是惯例的加油

加油，加油，加油

 

---------9.22

感冒

 

--------9.23

以为感冒做比赛会rp爆发----

结果昨晚爆零滚粗了，创历史新低---

还烧得飞起-------

cf 580 a

http://codeforces.com/problemset/problem/580/A

第一眼以为是求最长不下降子序列

几下敲完，发现过不了样例

然后发现让求的是最长的连续的不下降的子序列

所以用尺取法，也可以递推

写的尺取法写挫了，T掉

 1 #include  
 2 #include  
 3 #include 
 4 #include  
 5 #include
 6 #include
 7 #include

View Code

 

cf 580 b

http://codeforces.com/problemset/problem/580/B

昨晚题读错了，以为就排下序，wa了之后也没想去改---然后看C去了---

还是尺取法

今天写还是写挫了好多次，T了好多发，发现还是搞不清楚尺取法的边界该怎么弄

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #include
 7 using namespace std;
 8 
 9 const int maxn = 500005;
10 typedef long long LL;
11 
12 struct node{
13     int m,s;
14 }a[maxn];
15 
16 int n,d;
17 LL sum[maxn];
18 
19 int cmp(node n1,node n2){
20     if(n1.m != n2.m) return n1.m < n2.m;
21     return n1.s > n2.s;
22 }
23 
24 void solve(){
25     sort(a,a+n,cmp);
26     sum[0] = a[0].s;
27     for(int i = 1;i < n;i++) sum[i] = sum[i-1] + a[i].s;
28     
29     LL ans = -1,res = 0;
30     int minn = -1;
31     int j = 0;
32     for(int i = 0;i < n;i++){
33         while((j+1) < n && (a[j+1].m - a[i].m ) < d){
34             j++;
35         //    printf("i = %d  j = %d \n",i,j);
36         }
37         ans = max(ans,sum[j]-sum[i-1]);
38         if(j >= n) break;
39     //    i = j;
40     }
41     printf("%I64d\n",ans);
42 }
43 
44 int main(){
45     while(scanf("%d %d",&n,&d) != EOF){
46         for(int i = 0;i < n;i++) scanf("%d %d",&a[i].m,&a[i].s);
47         solve();
48     }
49     return 0;
50 }

View Code

 

cf 580 c

http://codeforces.com/contest/580/problem/C

这题的想法真是大错特错了，昨晚各种改---还是不对---挫爆---

是求从根到叶子节点的路径上，连续的有猫的点的个数小于等于m的叶子有几个

自己想的是，做两次dfs

第一次，把每条路径上，每个节点连续有多少只猫算出来

然后第二次dfs，从上到下去更新，连续的猫最多有多少只

然后最后扫一遍叶子节点的看满足的有多少就可以了

可是，这样从上到下更新的话，链状的可以，可是有分叉的时候就不行了---所以不对---

 

然后直接搜就好了

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 
 8 const int maxn = 500005;
 9 vector<int> g[maxn];
10 int n,m;
11 int a[maxn],sz[maxn],vis[maxn];
12 int res;
13 
14 void dfs(int u,int p,int cnt){
15     if(a[u]) cnt++;
16     else cnt = 0;
17     
18     if(cnt > m) return;
19     
20     if(g[u].size() == 1 && u != 1 && cnt <= m) res++;
21     for(int i = 0;i < g[u].size();i++){
22         int v = g[u][i];
23         if(v == p) continue;
24         dfs(v,u,cnt);
25     }
26     
27 }
28 
29 void solve(){
30     res = 0;
31     dfs(1,-1,0);
32     printf("%d\n",res);
33 }
34 
35 int main(){
36     while(scanf("%d %d",&n,&m) != EOF){
37         for(int i = 1;i <= n;i++) g[i].clear();
38         memset(a,0,sizeof(a));
39         
40         for(int i = 1;i <= n;i++) scanf("%d",&a[i]);
41         for(int i = 1;i <= n-1;i++){
42             int u,v;
43             scanf("%d %d",&u,&v);
44             g[u].push_back(v);
45             g[v].push_back(u);
46         }
47         solve();
48     }
49     return 0;
50 }

View Code

D是状压dp

再补---

E是线段树---还要用到hash什么的---------------------------

 

下次加油----总不会更挫了的说----->_<

 

---------9.24

gym 100685 G

http://codeforces.com/problemset/gymProblem/100685/G

补了暑假那一题lca

给出一个有向树，再给出m个询问，问从a能不能够到达b

正反向建图

然后dfs求出一个节点向上最远能够到达的距离，向下最远能够到达的距离

如果up[a] >= a到lca的距离，而且 down[b] >= b 到lca的距离

则说明 a可以到达b

  1 #include 
  2 #include 
  3 #include 
  4 #include 
  5 #include 
  6 #include 
  7 #include 
  8 using namespace std;
  9 
 10 
 11 typedef long long LL;
 12 const int INF = (1 << 30) - 1;
 13 const int maxn = 500010;
 14 const int MAX_LOG = 16;
 15 
 16 int T,n,m;
 17 int first[maxn],ecnt;
 18 int fa[MAX_LOG][maxn],dep[maxn];
 19 int  dis[maxn];
 20 int up[maxn],down[maxn],vis[maxn];
 21 
 22 struct edge{
 23     int v,next,type;
 24 }e[maxn << 1];
 25 
 26 void Add_edge(int u,int v,int c){
 27     e[++ecnt].next = first[u];
 28     e[ecnt].v = v;
 29     e[ecnt].type = c;
 30     first[u] = ecnt;
 31 }
 32 
 33 void init(){
 34     memset(first,-1,sizeof(first));
 35     ecnt=0;
 36 }
 37 
 38 void Dfs(int p,int pre,int d){
 39     fa[0][p] = pre;
 40     dep[p] = d;
 41     for(int i = first[p]; ~i; i = e[i].next){
 42         int v = e[i].v;
 43         if(v == pre) continue;
 44         dis[v] = dis[p] + 1;
 45         Dfs(v,p,d + 1);
 46     }
 47 }
 48     
 49 void Pre(){
 50     dis[1] = 0;
 51     Dfs(1,-1,0);
 52     for(int k = 0; k + 1 < MAX_LOG; ++k){
 53         for(int v = 1; v <= n; ++v){
 54             if(fa[k][v] < 0) fa[k + 1][v] = -1;
 55             else fa[k + 1][v] = fa[k][fa[k][v]];
 56         }
 57     }
 58 }
 59 
 60 int Lca(int u,int v){
 61     if(dep[u] > dep[v]) swap(u,v);
 62     for(int k = MAX_LOG - 1; k >= 0; --k){
 63         if((dep[v] - dep[u]) & (1 << k))
 64             v = fa[k][v];
 65     }
 66     if(u == v) return u; //uΪv�ĸ�
 67     for(int k = MAX_LOG - 1; k >= 0; --k){
 68         if(fa[k][u] != fa[k][v]){
 69             u = fa[k][u];
 70             v = fa[k][v];
 71         }
 72     }
 73     return fa[0][u]; //u��lcaֻ��һ��
 74 }
 75 
 76 void dfs(int u,int p){
 77     vis[u] = 1;
 78     for(int i = first[u];~i;i=e[i].next){
 79         int v = e[i].v;
 80         if(v == p) continue;
 81         if(e[i].type == 0) {
 82           down[v] = down[u] + 1;
 83           up[v] = 0;
 84         }
 85         else {
 86             up[v] = up[u] + 1;
 87             down[v] = 0;
 88         }
 89         dfs(v,u);
 90     }
 91 }
 92 
 93 void solve(int a,int b){
 94 //    for(int i = 1;i <= n;i++) printf("dis[%d] = %d\n",i,dis[i]);
 95 //    for(int i = 1;i <= n;i++) printf("up[%d] = %d  down[%d] = %d\n",i,up[i],i,down[i]);
 96     
 97     int lca =  Lca(a,b);
 98     int Up = dis[a]-dis[lca];
 99     int Down = dis[b]-dis[lca];
100 //    printf("dis[%d] = %d  dis[%d] = %d  dis[%d] = %d\n",lca,dis[lca],a,dis[a],b,dis[b]);
101     if(up[a] >= Up && down[b] >= Down) puts("Yes");
102     else puts("No");
103 }
104 
105 int main(){
106         init();
107         scanf("%d",&n);
108         for(int i = 1;i <= n;i++) dis[i] = INF;
109         for(int i = 1;i <= n-1;i++){
110             int a,b;
111             scanf("%d%d",&a,&b);
112             Add_edge(a,b,0);//����ı�
113             Add_edge(b,a,1);//����ı� 
114         }
115         Pre();
116         memset(up,0,sizeof(up));
117         memset(down,0,sizeof(down));
118         dfs(1,-1);
119         scanf("%d",&m);
120         for(int i = 1;i <= m;i++){
121             int a,b;
122             scanf("%d%d",&a,&b);
123             solve(a,b);
124         }
125     return 0;
126 }

View Code

 

cf 60 b

http://codeforces.com/problemset/problem/60/B

三维的dfs

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 
 8 int K,n,m;
 9 char g[15][15][15];
10 int vis[15][15][15];
11 int sx,sy,ans;
12 
13 void dfs(int x,int y,int z){
14    // printf("x = %d  y = %d  z = %d\n",x,y,z);
15     if(g[x][y][z] != '.' || vis[x][y][z]) return;
16     vis[x][y][z] = 1;
17     ans++;
18     
19     dfs(x+1,y,z);
20     dfs(x-1,y,z);
21     dfs(x,y+1,z);
22     dfs(x,y-1,z);
23     dfs(x,y,z+1);
24     dfs(x,y,z-1);
25 }
26 
27 int main(){
28     while(scanf("%d %d %d",&K,&n,&m) != EOF){
29         for(int k = 1;k <= K;k++){
30             for(int i = 1;i <= n;i++){
31                 for(int j = 1;j <= m;j++) cin >> g[i][j][k];
32             }
33         }
34         getchar();
35         scanf("%d %d",&sx,&sy);
36         memset(vis,0,sizeof(vis));
37         ans = 0;
38         dfs(sx,sy,1);
39         printf("%d\n",ans);
40     }
41     return 0;
42 }

View Code

 

喝了室友神奇的板蓝根，烧退了，感冒也好了好多，简直感动哭，简直灵丹妙药>_<

 

cf 461 b

http://codeforces.com/problemset/problem/461/B

给出一颗树，它的节点有黑白两种颜色，求将它划分成每个联通快有且仅有一个黑色节点的方案数

 

没有思路----只想到一条边该不该断，但是dp的状态和转移都没有想到------

题解

http://www.shuizilong.com/house/archives/category/uncategorized/acm/online-contest/codeforces/?variant=zh-cn

http://www.cnblogs.com/forgot93/p/3939231.html

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 
 8 typedef long long LL;
 9 const int mod = 1e9+7;
10 const int maxn = 100005;
11 vector<int> g[maxn];
12 int n;
13 int a[maxn];
14 LL dp[maxn][2];
15 
16 void dfs(int u,int p){
17     dp[u][a[u]] = 1;
18     for(int i = 0;i < g[u].size();i++){
19         int v = g[u][i];
20         if(v == p) continue;
21         dfs(v,u);
22         dp[u][1] = (dp[u][1]*(dp[v][1] + dp[v][0]) % mod + dp[u][0]*dp[v][1]%mod) % mod;
23         dp[u][0] = (dp[u][0]*dp[v][1]%mod + dp[u][0]*dp[v][0]%mod) % mod;
24     }
25 }
26 
27 int main(){
28     while(scanf("%d",&n) != EOF){
29         for(int i = 0;i <= n;i++) g[i].clear();
30         memset(a,0,sizeof(a));
31         memset(dp,0,sizeof(dp));
32         
33         for(int i = 0;i < n-1;i++){
34             int x;
35             scanf("%d",&x);
36             g[x].push_back(i+1);
37             g[i+1].push_back(x);
38         }
39         for(int i = 0;i < n;i++) scanf("%d",&a[i]);
40         
41         dfs(0,-1);
42         printf("%I64d\n",dp[0][1]);
43     }

44     return 0;
45 }

View Code

 

cf 513 G1

http://codeforces.com/problemset/problem/513/G1

给出一列数，定义一次操作为可以任意选择两个数l,r,将[l,r]之间的数翻转，现在操作k次，问最终状态的逆序对个数的期望

 

总的方案数位 C（n,2） + n (因为l,r可以一样)= n*(n+1)/2

然后枚举选不选当前的[l,r]的操作

然后 累加答案

只会数据最小的情况

------后面还有两题升级版-------------------------------------------

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 
 8 int n,k;
 9 int a[105];
10 double ans;
11 int sum;
12 
13 int nixudui(){
14     int cnt = 0;
15     for(int i = 0;i < n;i++){
16         for(int j = i+1;j < n;j++){
17             if(a[i] > a[j]) cnt++;
18         }
19     }
20     return cnt;
21 }
22 
23 void dfs(int k,double p){
24 //    printf("k = %d\n",k);
25     if(k == 0){
26 //        for(int i = 0;i < n;i++) printf("%d ",a[i]);
27     //    printf("\n");
28         int tmp = nixudui();
29         ans += 1.0*tmp*p;
30         return;
31     }
32     
33     for(int i = 0;i < n;i++){
34         for(int j = i+1;j <= n;j++){
35             reverse(a+i,a+j);
36             dfs(k-1,p/sum);
37             reverse(a+i,a+j);
38         }
39     }
40 }
41 
42 int main(){
43     while(scanf("%d %d",&n,&k) != EOF){
44         for(int i = 0;i < n;i++) scanf("%d",&a[i]);
45         
46         sum = (n+1)*n/2;
47         ans = 0;
48         dfs(k,1.0);
49         printf("%.15lf\n",ans);
50     }
51     return 0;
52 }

View Code

 

好====饿====啊=========

 

-----------9.25

cf 244 b

http://codeforces.com/problemset/problem/244/B

给出n，求1 到 n的数字中，构成它的数不超过两个的数字有多少个

先一直想有没有什么规律啊---还排列组合了好久--

然后想不出来---

看题解，，直接搜的，但是它搜到1e8就return了，说到1e9之间的要单独处理下

可是不懂怎么处理--

然后就改成到1e9  return, 也没有T掉-------

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #include<set>
 7 using namespace std;
 8 
 9 int ans,n;
10 
11 int ok(int x){
12     set<int> s;
13     while(x){
14         s.insert(x%10);
15         x = x/10;
16     }
17     return s.size() <= 2;
18 }
19 
20 void dfs(int num){
21     if(num > 0 && num <= n) ans++;
22     if(num >= 1e9) return;
23     for(int a = 0; a <= 9;a++){
24         if(num*10+a > 0){
25             if(ok(num*10+a)){
26                 dfs(num*10+a);
27             }
28         }
29     }
30 }
31 
32 int main(){
33     while(scanf("%d",&n) != EOF){
34         ans = 0;
35         dfs(0);
36         printf("%d\n",ans);
37     }
38     return 0;
39 }

View Code

 

cf 283 b

http://codeforces.com/problemset/problem/283/B

虽然知道该去记忆化搜索，可是还是不懂写--

看了题解之后写，还是 wa了

因为得先判断dp[][]是不是算过了，再看这个状态是不是被访问过了，如果在dp[][]没有被计算过，且再一次访问，说明才是无解的

先想不通，后来手算了下wa的那组样例就好懂些了

 

还是不懂搜啊，不懂记忆化搜索，不懂深搜，不懂dp-------------------

加油--------------------------------------------------------------------------gooooooooooooooooooooooooooo

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 
 8 typedef long long LL;
 9 const int maxn = 200005;
10 LL dp[maxn][2];
11 int a[maxn];
12 int vis[maxn][2];
13 int n;
14 
15 //wei ziji jiayou >_<******
16 
17 LL dfs(int x,int dir){
18     if(x <= 0 || x > n) return 0;
19     if(dp[x][dir] >= 0) return dp[x][dir];
20     if(vis[x][dir]) return -1;
21     
22     vis[x][dir] = 1;
23     
24     LL res;
25     if(dir > 0) res = dfs(x + a[x],!dir);
26     else res = dfs(x-a[x],!dir);
27     
28     if(res < 0) return dp[x][dir] = -1;
29     return  dp[x][dir] = res + a[x];
30 }
31 
32 int main(){
33     while(scanf("%d",&n) != EOF){
34         memset(dp,-1,sizeof(dp));
35         memset(vis,0,sizeof(vis));
36         for(int i = 2;i <= n;i++) scanf("%d",&a[i]);
37         
38         for(int i = 1;i <= n-1;i++){
39             LL ans = dfs(i+1,0);
40             if(ans < 0) puts("-1");
41             else printf("%I64d\n",ans+i);
42         }
43     }
44     return 0;
45 }

View Code

 

---------9.26

上海打出名额啦，感动哭----

 

--------9.27

hdu 5491

觉得自己的思路还是很混乱

后来看了这篇题解写的，

http://blog.csdn.net/queuelovestack/article/details/48767981

用vector会T掉，，然后用数组写的

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 using namespace std;
 7 
 8 //wei ziji jiayou >_<99
 9 
10 typedef long long LL;
11 int x,l,r;
12 LL powmy[55];
13 
14 LL change(int p[],int num){
15     LL c = 0;
16     int sz = num;
17     for(int i = 0;i <= sz;i++){
18         c += 1LL*p[i]*powmy[sz-i];
19     }
20     return c;
21 }
22 
23 void solve(){
24     int a[55];
25     int y = x;
26     int p = 0;
27     while(x){
28         a[p++] = x%2;
29         x = x/2;
30     }
31     a[p] = 0;
32     
33     int c[55];
34     for(int i = 0;i <= p;i++) c[i] = a[p-i];
35     
36 //    for(int i = 0;i <= p;i++) printf("c[%d] = %d\n",i,c[i]);
37         
38     long long  res = 6000000000;
39     for(int i = 0;i <= p;i++){
40         int pos;
41         if(c[i] == 0) pos = i;
42         else continue;
43         
44         int b[55];
45         int cnt = 1;
46         
47         for(int j = 0;j < pos;j++) {
48             b[j] = c[j];
49             if(c[j] == 1) cnt++;
50         }
51         b[pos] = 1;
52         for(int j = pos+1;j <= p;j++) b[j] = 0;
53     //    for(int i = 0;i <= p;i++) printf("%d",b[i]);
54     //    printf("-----------\n");
55         
56         for(int j = p;j > pos;j--){
57             if(cnt >= l) break;
58             b[j] = 1;
59             cnt++;
60         }
61     //    printf("cnt = %d\n",cnt);
62       //  for(int i = 0;i <= p;i++) printf("%d",b[i]);
63         //printf("\n");
64         long long  z = change(b,p);
65         
66         if(z > y && cnt <= r && cnt >= l ) {
67             res = min(res,z);
68         }
69     }
70     printf("%I64d\n",res);
71 }
72 
73 int main(){
74     int T;
75     powmy[0] = 1;
76     for(int i = 1;i <= 32;i++) powmy[i] = 2*powmy[i-1];
77     scanf("%d",&T);
78     int kase = 0;    
79     
80 //    for(int i = 1;i <= 32;i++) printf("pow[%d] = %I64d\n",i,pow[i]);
81     
82     while(T--){
83         scanf("%d %d %d",&x,&l,&r);
84         printf("Case #%d: ",++kase);
85         solve();
86     }
87     return 0;
88 }

View Code

 

转载于:https://www.cnblogs.com/wuyuewoniu/p/4827735.html