Bestcoder Round#45

1001

给定数n，要我们求该数的二进制中有多少组1， 相邻的1称为1组， 直接位运算摸你即可

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*

 */

 int main()
 {
     int t;
     LL n;
     scanf("%d", &t);
     while (t--)
     {
         scanf("%I64d", &n);
         int ans = ;
         bool flag = true;
         while (n)
         {
             if ((n & ))
             {
                 if (flag)
                 {
                     ans++;
                     flag = false;
                 }
             }
             else
                 flag = true;

             n >>= ;
         }
         printf("%d\n", ans);
     }
     return ;
 }

1002

比赛的时候，一直认为求逆序对，要用树状数组做， 就YY出了一个树状数组的解法。

我把询问按照L从小到大排序，然后分为两种情况

对于第一种情况，我们只要将左边的数从树状数组中减去，然后加上右边的数即可。

对于第二种情况，我们将数状数组情况， 重新建树状数组

其实比赛完之后，仔细想想，如果存在很多第二种情况（应该最多只有1000种，因为N<=1000） ， 那么时间复杂度是N*N*logN， 应该是勉强可以过， 或者直接TLE

不过自己YY出来这种想法， 还是挺好的。

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*

 */
 struct Node
 {
     int l, r;
     int id;
     bool operator<(const Node &rhs)const
     {
         if (l == rhs.l)
             return r < rhs.r;
         return l < rhs.l;
     }
 }Q[+];
 int a[ + ];
 int b[ + ];
 map<int, int> mark;
 int ans[ + ];
 int sum[ + ];
 int lowbit(int x)
 {
     return x & (-x);
 }
 void modify(int pos, int val, int n)
 {
     while (pos <= n)
     {
         sum[pos] += val;
         pos += lowbit(pos);
     }
 }
 int getSum(int pos)
 {
     int ret = ;
     while (pos > )
     {
         ret += sum[pos];
         pos -= lowbit(pos);
     }
     return ret;
 }
 int main()
 {
     int n, q;
     while (scanf("%d%d", &n, &q) != EOF)
     {
         memset(sum, , sizeof(sum));
         for (int i = ; i < n; ++i)
         {
             scanf("%d", &a[i]);
             b[i] = a[i];
         }
         for (int i = ; i < q; ++i)
         {
             scanf("%d%d", &Q[i].l, &Q[i].r);
             Q[i].l--;
             Q[i].r--;
             Q[i].id = i;
         }
         sort(a, a + n);
         sort(Q, Q + q);
         n = unique(a, a + n) - a;
         //printf("%d\n", n);
         for (int i = ; i < n; ++i)
         {
             mark[a[i]] = i + ;
             //printf("%d %d\n", a[i], i + 1);
         }
         int preL = ;
         int preR = ;
         int t;
         int tmp = ;
         for (int i = ; i < q; ++i)
         {
             if (preR -  > Q[i].r)//第二种情况， 清空树状数组
             {
                 memset(sum, , sizeof(sum));
                 preR = Q[i].l;
                 preL = Q[i].l;
                 tmp = ;
             }
             for (int j = preL; j < Q[i].l; ++j)//减去左边的区间
             {
                 tmp -= getSum(mark[b[j]]-);
                 modify(mark[b[j]], -, mark[a[n - ]]);
                 preL = Q[i].l;

             }

             for (int j = preR; j <= Q[i].r; ++j)
             {

                 modify(mark[b[j]], , mark[a[n-]]);
                 tmp += getSum(mark[a[n-]])-getSum(mark[b[j]]);
             }
             preR = Q[i].r + ;
             ans[Q[i].id] = tmp;
         }
         for (int i = ; i < q; ++i)
             printf("%d\n", ans[i]);
     }
     return ;
 }

正解应该是。

设ans1[i][j] 为区间i-->j,包含a[i]的逆序对数，  首先我们暴力算好ans1[i][j] ,时间复杂度为O(N*N)

设ans2[i][j] 为区间i-->j中的逆序对数，

那么ans2[i][j] = ans1[i][j] + ans[i+1][j] +...+ans[j][j]

优化一下就是， 如果ans2[i+1][j] 已经算好了，  那么ans2[i][j] = ans2[i+1][j] + ans1[i][j];

所以这个的时间复杂度也是O(N*N),而且 ans1 和ans2可以合成一个数组

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*

 */
 const int N =  + ;
 int ans[N][N];
 int a[N];
 int main()
 {
     int n, q;
     while (scanf("%d%d", &n, &q) != EOF)
     {
         for (int i = ; i <= n; ++i)
             scanf("%d", &a[i]);

         //这里的ans[i][j] 表示区间i-->j， 包含元素a[i]的逆序对数
         for (int i = ; i <= n; ++i)
         for (int j = i; j <= n; ++j)
             ans[i][j] += ans[i][j - ] + (a[i] > a[j] ?  : );

         //那么 ans[i][j] 要表示区间i-->j的逆序对数时， ans[i][j] += ans[i+1][j] + ans[i+2][j]+...+ans[j][j]
         // 如果ans[i+1][j]已经算出来了，  那么ans[i][j] += ans[i+1][j] 即可,  因为贡献是后缀和性质的
         for (int j = ; j <= n; ++j)
         for (int i = j; i >= ; --i)
             ans[i][j] += ans[i + ][j];
         int l, r;
         while (q--)
         {
             scanf("%d%d", &l, &r);
             printf("%d\n", ans[l][r]);
         }
     }
     return ;
 }

1003

给我们一棵树，每个节点都有权值， 有两个操作

0 x y ,  将节点x的权值改为y

1 x y   询问x->y 的路径上， 是否有权值的次数出现奇数次（保证最多只有一个奇数次） 如果没有，输出-1， 如果有， 输出那个权值

任意两点的路径， 可以用lca求出， 然后要求权值是不是出现奇数次， 可以用异或，   a^a = 0  ,  a^a^a=a,

然而这并没有什么用，TLE， 如果树退化成链， 那么每次询问的时间复杂度是O(N)，每次询问的复杂度要O(logN)才行

 #pragma comment(linker, "/STACK:102400000,102400000")
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*
 RE
 */
 const int N =  + ;
 struct Edge
 {
     int to, next;
 }g[N];

 int value[N], head[N], e, parent[N], depth[N];
 void addEdge(int a, int b)
 {
     g[e].to = b;
     g[e].next = head[a];
     head[a] = e++;
 }
 void dfs(int u, int fa, int d)
 {
     depth[u] = d;
     for (int i = head[u]; i != -; i = g[i].next)
     {
         int v = g[i].to;
         if (v == fa) continue;
         dfs(v, u,d + );
     }
 }

 int solve(int x, int y)
 {
     if (x == y)
         return value[x];
     int ret = ;
     ret ^= value[x];
     //ret ^= value[y];
     if (depth[x] < depth[y])
         swap(x, y);
     int t = y;
     int d = depth[x];
     while(d > depth[y])
     {
         x = parent[x];
         d--;
         ret ^= value[x];
     }
     while (x!=y)
     {
         x = parent[x];
         y = parent[y];
         ret ^= value[x];
         ret ^= value[y];
     }
     if (t != y)
         ret ^= value[y];
     return ret;

 }
 int main()
 {
     int t, n, q, a, b, op;
     scanf("%d", &t);
     while (t--)
     {
         memset(parent, -, sizeof(parent));
         memset(depth, , sizeof(depth));
         memset(head, -, sizeof(head));
         e = ;
         scanf("%d%d", &n, &q);
         for (int i = ; i < n; ++i)
         {
             scanf("%d%d", &a, &b);
             addEdge(a, b);
             addEdge(b, a);
             parent[b] = a;

         }
         int root = ;
         while (parent[root] != -)
             root = parent[root];
         dfs(root,-,);
         for (int i = ; i <= n; ++i)
         {
             scanf("%d", &value[i]);
             value[i]++;
         }
         for (int i = ; i < q; ++i)
         {
             scanf("%d%d%d", &op, &a, &b);
             if (op == )
                 value[a] = b;
             else
             {
                 int ret = solve(a, b);
                 printf("%d\n", ret ? ret- : -);
             }
         }
     }
     return ;
 }

题解说这题要用树链剖分， 然后我并不懂