• codeforces(Intel Code Challenge Elimination Round (Div.1 + Div.2, combined) )(C,D)


    C. Destroying Array
    time limit per test
    1 second
    memory limit per test
    256 megabytes
    input
    standard input
    output
    standard output

    You are given an array consisting of n non-negative integers a1, a2, ..., an.

    You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.

    After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.

    Input

    The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the length of the array.

    The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).

    The third line contains a permutation of integers from 1 to n — the order used to destroy elements.

    Output

    Print n lines. The i-th line should contain a single integer — the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.

    Examples
    Input
    4
    1 3 2 5
    3 4 1 2
    Output
    5
    4
    3
    0
    Input
    5
    1 2 3 4 5
    4 2 3 5 1
    Output
    6
    5
    5
    1
    0
    Input
    8
    5 5 4 4 6 6 5 5
    5 2 8 7 1 3 4 6
    Output
    18
    16
    11
    8
    8
    6
    6
    0
    Note

    思路:并查集;

    倒着来做,每次我们向原来的序列中加点,那么我们如果知道他的左边i-1和右边i+1,是否已经存在,那么我们就可以将他们合并,这个用并查集维护就可以了,然后,用当前加入的点,所构成的段去更新最大值即可。

     1 #include<stdio.h>
     2 #include<algorithm>
     3 #include<iostream>
     4 #include<string.h>
     5 #include<queue>
     6 #include<set>
     7 #include<math.h>
     8 #include<map>
     9 using namespace std;
    10 typedef long long LL;
    11 LL ans[100005];
    12 int bns[100005];
    13 int bin[100005];
    14 int du[100005];
    15 LL ask[100005];
    16 bool flag[100005];
    17 LL cost[100005];
    18 int main(void)
    19 {
    20     int n;
    21     scanf("%d",&n);
    22     {
    23         int i,j;memset(cost,0,sizeof(cost));
    24         for(i = 1; i <= n; i++)
    25         {
    26             scanf("%lld",&ans[i]);
    27         }
    28         for(i = 1; i <= n; i++)
    29         {
    30             scanf("%d",&bns[i]);
    31         }
    32         for(i = 0; i <= 100000; i++)
    33         {
    34             bin[i] = i;
    35             du[i] = 1;
    36         }
    37         LL maxx = 0;
    38         for(i = n; i >= 1; i--)
    39         {
    40             ask[i] = maxx;
    41             flag[bns[i]] = true;
    42             cost[bns[i]] = ans[bns[i]];
    43             maxx =max(maxx,ans[bns[i]]);
    44             if(flag[bns[i]-1])
    45             {
    46                 int xx = bns[i];
    47                 int yy = bns[i]-1;
    48                 int x,y;
    49                 for(x = xx; x!=bin[x];)
    50                     x = bin[x];
    51                 for(y = yy; y!=bin[y];)
    52                     y = bin[y];
    53                 if(du[x]>du[y])
    54                 {
    55                     bin[y] = x;
    56                     du[x]+=du[y];
    57                     cost[x]+=cost[y];
    58                     maxx = max(maxx,cost[x]);
    59                 }
    60                 else
    61                 {
    62                     bin[x] = y;
    63                     du[y]+=du[x];
    64                     cost[y]+=cost[x];
    65                     maxx = max(maxx,cost[y]);
    66                 }
    67             }
    68                  if(flag[bns[i]+1])
    69             {
    70                 int xx = bns[i];
    71                 int yy = bns[i]+1;
    72                 int x,y;
    73                 for(x = xx; x!=bin[x];)
    74                     x = bin[x];
    75                 for(y = yy; y!=bin[y];)
    76                     y = bin[y];
    77                 if(du[x]>du[y])
    78                 {
    79                     bin[y] = x;
    80                     du[x]+=du[y];
    81                     cost[x]+=cost[y];
    82                     maxx = max(maxx,cost[x]);
    83                 }
    84                 else
    85                 {
    86                     bin[x] = y;
    87                     du[y]+=du[x];
    88                     cost[y]+=cost[x];
    89                     maxx = max(maxx,cost[y]);
    90                 }
    91             }
    92         }
    93         for(i = 1;i <= n;i++)
    94         {
    95             printf("%lld
    ",ask[i]);
    96         }
    97     }
    98     return 0;
    99 }
    C
    D. Generating Sets
    time limit per test
    2 seconds
    memory limit per test
    256 megabytes
    input
    standard input
    output
    standard output

    You are given a set Y of n distinct positive integers y1, y2, ..., yn.

    Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:

    1. Take any integer xi and multiply it by two, i.e. replace xi with xi.
    2. Take any integer xi, multiply it by two and add one, i.e. replace xi with xi + 1.

    Note that integers in X are not required to be distinct after each operation.

    Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.

    Note, that any set of integers (or its permutation) generates itself.

    You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.

    Input

    The first line of the input contains a single integer n (1 ≤ n ≤ 50 000) — the number of elements in Y.

    The second line contains n integers y1, ..., yn (1 ≤ yi ≤ 109), that are guaranteed to be distinct.

    Output

    Print n integers — set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.

    Examples
    Input
    5
    1 2 3 4 5
    Output
    4 5 2 3 1 
    Input
    6
    15 14 3 13 1 12
    Output
    12 13 14 7 3 1 
    Input
    6
    9 7 13 17 5 11
    Output
    4 5 2 6 3 1 
    思路:贪心;
    每次选取当前数中最大的进行除2,当队列中没有的时候将新的数加入队列继续,如果存在则一直进行下去,如果得到0,那么说明当前的数已经不能分解了.
    复杂度(n*log(n)^2)
     1 #include<stdio.h>
     2 #include<algorithm>
     3 #include<iostream>
     4 #include<string.h>
     5 #include<queue>
     6 #include<set>
     7 #include<math.h>
     8 #include<map>
     9 using namespace std;
    10 typedef long long LL;
    11 int ans[50005];
    12 int bns[50005];
    13 typedef struct pp
    14 {
    15         int x;
    16         bool operator<(const pp &cx)const
    17         {
    18                 return cx.x>x;
    19         }
    20 } ss;
    21 priority_queue<ss>que;
    22 map<int,int>my;
    23 int main(void)
    24 {
    25         int n;
    26         while(scanf("%d",&n)!=EOF)
    27         {
    28                 int i,j;int cn = 0;
    29                 my.clear();
    30                 while(!que.empty())
    31                         que.pop();
    32                 for(i = 0; i < n; i++)
    33                 {
    34                         scanf("%d",&ans[i]);
    35                         ss ak;
    36                         ak.x = ans[i];
    37                         que.push(ak);
    38                         my[ans[i]]++;
    39                 }
    40                 while(true&&!que.empty())
    41                 {
    42                         ss ak = que.top();
    43                         //printf("%d
    ",ak.x);
    44                         que.pop();
    45                         int v = ak.x;
    46                         my[ak.x]--;
    47                         int c = ak.x/2;
    48                         while(my.count(c))
    49                         {
    50                               c/=2;
    51                         }
    52                         if(c == 0)
    53                         {
    54                             bns[cn++] = v; break;
    55                         }
    56                         else
    57                         {
    58                             ak.x = c;
    59                             que.push(ak);
    60                             my[c]++;
    61                         }
    62                 }
    63                 while(!que.empty())
    64                 {
    65                     bns[cn++] = que.top().x;
    66                     que.pop();
    67                 }
    68                 printf("%d",bns[0]);
    69                 for(i = 1;i < cn;i++)
    70                 {
    71                     printf(" %d",bns[i]);
    72                 }
    73                 printf("
    ");
    74         }
    75         return 0;
    76 }
    D
    油!油!you@
  • 相关阅读:
    Spring整合hibernate4:事务管理
    eclipse添加约束文件
    转]@SuppressWarnings 详解
    spring + springMVC +hibernate 配置2
    spring +spring+ hibernate配置1
    eclipse下 hibernate逆向数据库操作示例!!
    Spring+hibernate 配置实例
    dubbo接口快速测试技巧
    Spring Boot Starter列表
    Spring Boot Starters是什么?
  • 原文地址:https://www.cnblogs.com/zzuli2sjy/p/5927531.html
Copyright © 2020-2023  润新知