2017-10-02-morning

T1 一道图论神题(god)

Time Limit:1000ms   Memory Limit:128MB

题目描述

LYK有一张无向图G={V,E}，这张无向图有n个点m条边组成。并且这是一张带权图，只有点权。

LYK想把这个图删干净，它的方法是这样的。每次选择一个点，将它删掉，但删这个点是需要代价的。假设与这个点相连的还没被删掉的点是u1,u2,…,uk。LYK将会增加a[u1],a[u2],…,a[uk]的疲劳值。

它想将所有点都删掉，并且删完后自己的疲劳值之和最小。你能帮帮它吗？

输入格式(god.in)

第一行两个数n,m表示一张n个点m条边的图。

第二行n个数ai表示点权。

接下来m行每行三个数u,v，表示有一条连接u,v的边。数据保证任意两个点之间最多一条边相连，并且不存在自环。

输出格式(god.out)

你需要输出这个最小疲劳值是多少。

输入样例

4 3

10 20 30 40

1 4

1 2

2 3

输出样例

40

样例解释

一个合理的方法是先删4号点，此时有10点疲劳值。接下来删3号点，获得20点疲劳值，再删2号点，获得10点疲劳值，最后删1号点，没有疲劳值。总计40点疲劳值。

对于30%的数据n<=10。

对于60%的数据n,m<=1000。

对于100%的数据1<=n,m,ai<=100000

 /*
 对于一条边的两个端点，肯定是选权值大最优
 然后对于每条边，都采取这种策略就完成了
 */
 #include <algorithm>
 #include <cstdio>

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N();
 int n,m,val[N];
 long long ans;

 int Presist()
 {
     freopen("god.in","r",stdin);
     freopen("god.out","w",stdout);
     read(n),read(m);
     for(int i=; i<=n; ++i)    read(val[i]);
     for(int u,v,i=; i<=m; ++i)
     {
         read(u),read(v);
         ans+=(long long)std::min(val[u],val[v]);
     }
     printf("%I64d",ans);
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**){;}

贪心AC

T2 位运算2(bit)

Time Limit:1000ms   Memory Limit:128MB

题目描述

LYK拥有一个十进制的数N。它赋予了N一个新的意义：不考虑N的符号，将N每一位都拆开来后再加起来就是N所拥有的价值。例如数字123拥有6的价值，数字999拥有27的价值，数字-233拥有8的价值。

假设数字N的价值是K，LYK想找到一个价值是K+1的数字，当然这个答案实在太多了，LYK想使得这个价值为K+1的数字尽可能大，并且需要保证这个数字小于N。

输入格式(bit.in)

一个整数N。

输出格式(bit.out)

一个数表示答案。你需要输出一个整数，且这个数不包含前导0。

输入样例1

199

输出样例1

-299

输入样例2

1520

输出样例2

1512

对于20%的数据|N|<=10

对于40%的数据|N|<=100

对于60%的数据|N|<=10^9

对于80%的数据|N|<=10^1000

对于100%的数据|N|<=10^100000。

对于负数的情况从后往前找第一个不是9的数++

 #include <cstring>
 #include <cstdio>

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 char s[];
 int n,num[];

 inline void work1()
 {
     int i,flag=;
     for(i=; i<=n; ++i) num[i]=s[i]-'';
     for(i=n; i>; --i)
         if(num[i]!=)
         {
             num[i]++;
             flag=;
             break;
         }
     printf("-");
     if(!flag) printf("");
     for(int i=; i<=n; ++i)    printf("%d",num[i]);
 }

 int K;
 inline void work2()
 {
     for(int i=; i<=n; ++i) num[i]=s[i]-'',K+=num[i];
     if(num[]==&&num[]==&&n==) { printf("%d\n",); return ; }
     if(++K<&&n==&&num[]==) { printf("%d\n",K); return ; }
 }

 int Presist()
 {
 //    freopen("bit.in","r",stdin);
 //    freopen("bit.out","w",stdout);
     scanf("%s",s+);n=strlen(s+);
     if(s[]=='-') work1();
     else work2();
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**){;}

考试只做了负数和特殊正数的情况60分

对于正数的情况，

①设当前位置i到最后一位的价值为tot，如果tot<=(n-i)*9+num[i]-1

最优解为1~i-1为原数，i+1~n尽量填最大，num[i]--；

②否则，为绝对数值最小的负数，等价于位数最小的负数，第一位之后填尽量多的9

 #include <cstring>
 #include <cstdio>

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N();
 int n,num[N],k[N],K;
 char s[N];

 inline void work1()
 {
     int i,flag=;
     for(i=; i<=n; ++i) num[i]=s[i]-'';
     for(i=n; i>; --i)
         if(num[i]!=)
         {
             num[i]++;
             flag=;
             break;
         }
     printf("-");
     if(!flag) printf("");
     for(int i=; i<=n; ++i)    printf("%d",num[i]);
 }

 inline void work2()
 {
     for(int i=; i<=n; ++i) num[i]=s[i]-'',K+=num[i];
     int tot=num[n]+;
     for(int i=n-; i>=; --i)
     {
         tot+=num[i];
         if(!num[i]) continue;
         if(tot<=num[i]-+(n-i)*)
         {
             num[i]--;tot-=num[i];
             if(num[]) printf("%d",num[]);
             for(int j=; j<=i; ++j) printf("%d",num[j]);
             for(int j=i+; j<=n; ++j)
                 if(tot>=) printf(""),tot-=;
                 else printf("%d",tot),tot=;
             return ;
         }
     }
     printf("-"); K++; int len=K/;
     if(K%) printf("%d",K%);
     for(; len--; ) printf("");
 }

 int Presist()
 {
 //    freopen("bit.in","r",stdin);
 //    freopen("bit.out","w",stdout);
     scanf("%s",s+);n=strlen(s+);
     if(s[]=='-') work1();
     else work2();
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**){;}

AC

T3 逆序对(pair)

Time Limit:1000ms   Memory Limit:128MB

题目描述

LYK最近在研究逆序对。

这个问题是这样的。

一开始LYK有一个2^n长度的数组ai。

LYK有Q次操作，每次操作都有一个参数k。表示每连续2^k长度作为一个小组。假设n=4,k=2，则a[1],a[2],a[3],a[4]为一个小组，a[5],a[6],a[7],a[8]为一个小组，a[9],a[10],a[11],a[12]为一个小组，a[13],a[14],a[15],a[16]也为一个小组。

然后LYK对于每个小组都翻转，也就是说原数组会变成a[4],a[3],a[2],a[1],a[8],a[7],a[6],a[5],a[12],a[11],a[10],a[9],a[16],a[15],a[14],a[13]。之后它想求出这2^n个数的逆序对是多少。

因此你需要输出对于每次操作，操作完后这2^n个数的逆序对有多少对。

两个数ai,aj被称为逆序对当且仅当i<j且ai>aj。

输入格式(pair.in)

第一行一个数n。

接下来一行2^n个数ai表示一开始的数组。

接下来一行一个数Q，表示操作的次数。

接下来一行Q个数，表示每次操作的参数k。

输出格式(pair.out)

Q行，表示每次操作后的答案。

输入样例

2

2 1 4 3

4

1 2 0 2

输出样例

0

6

6

0

样例解释

第一次操作，{2,1,4,3}->{1,2,3,4}

第二次操作，{1,2,3,4}->{4,3,2,1}

第三次操作，{4,3,2,1}->{4,3,2,1}

第四次操作，{4,3,2,1}->{1,2,3,4}

对于30%的数据n<=10，Q<=10。

对于50%的数据n<=10，Q<=1000。

对于80%的数据n<=10，Q<=200000。

对于100%的数据n<=17，Q<=200000，1<=ai<=2^n。

归并排序求逆序对的时候，用st表维护从第i个位置，长为2^j的区间的逆序对个数

然后求出对应区间的顺序对个数

维护所有长为2^i的区间的逆序对个数rev[i]和顺序对个数seq[i]

统计答案的时候，拆分就是swap（rev，seq）

在这里顺序对个数是用总个数-逆序对个数求的，要注意相等的情况

因为用总个数-逆序对个数=顺序对个数+相等的数对

所以归并过程中，还要预处理从第i个位置，长为2^j的区间的相等数对个数

计算rev，seq时，同时计算same[i]，表示所有长为2^i的区间相等的数对个数

求解的时候 先swap（rev，seq），然后rev-=same，再seq=总的-rev

 #include <cstdio>

 #define LL long long
 #define swap(a,b) {LL c=a;a=b;b=c;}

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N(<<);
 int n,nn,m,a[N+],log2[N+];

 int last[N+],order[N+];
 LL st[N+][],euq[N+][];
 LL same[N+],seq[N+],rev[N+],sum[N+];
 void Merge_sort(int l,int r)
 {
     if(l==r) return ;
     int mid=l+r>>;
     Merge_sort(l,mid);
     Merge_sort(mid+,r);
     int i,j,k,len=log2[r-l+];
     for(i=l; i<=r; ++i) last[i]=i;
     for(i=r; i>l; --i)
         if(a[i]==a[i-]) last[i-]=last[i];
     for(i=k=l,j=mid+; i<=mid&&j<=r; )
         if(a[i]==a[j]) euq[l][len]+=last[j]-j+,order[k++]=a[i++];
         else if(a[i]>a[j]) st[l][len]+=mid-i+,order[k++]=a[j++];
              else order[k++]=a[i++];
     for(; i<=mid; ) order[k++]=a[i++];
     for(; j<=r; ) order[k++]=a[j++];
     for(i=l; i<=r; ++i) a[i]=order[i];
 }

 inline void Prepare()
 {
     for(int i=; i<=nn; ++i) log2[i]=log2[i>>]+;
     Merge_sort(,nn);
     for(int i=; i<=n; ++i) sum[i]=1ll*(<<i-)*(<<i-);
     for(int len=,i=; i<=n; ++i,len<<=)
       for(int j=; j<=nn; j+=len)
       {
         rev[i]+=st[j][i],
         same[i]+=euq[j][i],
         seq[i]+=sum[i]-st[j][i];
       }
 }

 int Presist()
 {
 //    freopen("pair.in","r",stdin);
 //    freopen("pair.out","w",stdout);
     read(n),nn=<<n;
     for(int i=; i<=nn; ++i) read(a[i]);
     Prepare(),read(m);
     for(int k; m--; )
     {
         read(k);long long ans=;
         for(int i=; i<=k; ++i)
         {
             swap(rev[i],seq[i]);
             rev[i]-=same[i];
             seq[i]=sum[i]*nn/(<<i)-rev[i];
         }
         for(int i=; i<=n; ++i) ans+=rev[i];
         printf("%I64d\n",ans);
     }
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC