算法设计与分析 - AC 代码 - 第 6 弹（重复第 3 弹）

 PTA-算法设计与分析
 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;
 long max3(long a,long b,long c)
 {   if(a<b) a=b;
     if(a>c) return a;
     else return c;
 }
 long maxSubSum(int a[],int left,int right)
 {   int i,j;
     long maxLeftSum,maxRightSum;
     long maxLeftBorderSum,leftBorderSum;
     long maxRightBorderSum,rightBorderSum;
     if(left==right)
     {   if(a[left]>)
             return a[left];
         else
             return ;
     }
     int mid=(left+right)/;
     maxLeftSum=maxSubSum(a,left,mid);
     maxRightSum=maxSubSum(a,mid+,right);
     maxLeftBorderSum=,leftBorderSum=;
     for(i=mid;i>=left;i--)
     {   leftBorderSum+=a[i];
         if(leftBorderSum>maxLeftBorderSum)
             maxLeftBorderSum=leftBorderSum;
     }
     maxRightBorderSum=,rightBorderSum=;
     for(j=mid+;j<=right;j++)
     {   rightBorderSum+=a[j];
         if(rightBorderSum>maxRightBorderSum)
             maxRightBorderSum=rightBorderSum;
     }
     return max3(maxLeftSum,maxRightSum,maxLeftBorderSum+maxRightBorderSum);
 }

 int main()
 {   int n;
     cin>>n;
     int a[n];
     for(int i=;i<n;i++)
     {   cin>>a[i];
     }
     cout<<maxSubSum(a,,n-)<<endl;
 }
 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;

 int n;
 int flag[+];
 int count(int n) {
     int cnt = ;
     flag[] = ;
     for (int i = ; i <= n; ++i) {
         flag[i++] = ;               // 奇数位
         flag[i] = ;                 // 偶数位直接过滤
     }
     for (int i = ; i <= sqrt(n*); ++i) {
         if (flag[i] != ) continue;
         for (int j = i*i; j <= n; j += i) {
                             // 将倍数转换为加法
             flag[j] = ;
         }
     }
     for (int i = ; i <= n; ++i)
         cnt += flag[i];
     return cnt;
 }
 int main()
 {   cin>>n;
     cout<<count(n);
 }
 - c++(g++)
 #include <stdio.h>
 #include <string.h>
 int main()
 {
     char a[],b[];
     int i,j,k,m,n,c[]={};
     while(gets(a)&&a[]!='#')
     {
         gets(b);
         m=strlen(a);
         n=strlen(b);
         for(i=;i<m;i++)
           {
             c[i]=;
           for(j=;j<n;j++)
           {
             if(a[i]==b[j])
                c[i]++;
           }
           }
           for(i=;i<m;i++)
             printf("%c %d\n",a[i],c[i]);
     }
     return ;
 }

 - c++(g++)
 #include<stdio.h>
 long long d[];
 int main()
 {
     int T,n,i;
     scanf("%d",&T);
     for(i=;i<;i++) d[i]=;
     d[]=;
     d[]=;
     for(i=;i<=;i++)
         d[i]=((i-)*(d[i-]%+d[i-]%))%;
     /*
         right now: MOD=1000000007;

       for(i=3;i<=100;i++)
         {
         a[i]=a[i-1]+a[i-2];
         a[i]%=MOD;
         a[i]*=i-1;
         a[i]%=MOD;
         }
     */
     while(T--)
     { 

        scanf("%d",&n);
        printf("%lld\n",d[n]);
     }
     return ;
 }
 - c++(g++)

 #include"iostream"
 #include"cstdio"
 #include"cstring"
 using namespace std;
 const int  maxn = ;

 int num[maxn + ];
 int c1[maxn + ], c2[maxn + ];

 int main(){
     int T;
     scanf("%d",&T);
     while(T --){
         for(int i = ;i <= ;i ++)
             scanf("%d", &num[i]);
         memset(c1, , sizeof c1);
         memset(c2, , sizeof c2);
         for(int i = ;i <= num[];i ++)
             c1[i] = ;
         for(int i = ;i <= ;i ++){        //共有26个多项式
             if(num[i] == ) continue;
             for(int j = ;j <= maxn;j ++){  //共有maxn+1项
                 for(int k = ;k <= num[i] && j + k*i <= maxn;k ++)
                     c2[j + k*i] += c1[j];
             }
             for(int j = ;j <= maxn;j ++){
                 c1[j] = c2[j];
                 c2[j] = ;
             }
         }
         int sum = ;
         for(int j = ;j <= maxn;j ++)
             sum += c1[j];
         printf("%d\n",sum);
     }
     return ;
 }
 - c++(g++)
 #include <iostream>
 using namespace std;
 const int MAXA=;
 int a[MAXA];

 int max(int x, int y)
 {
     if (x < y)
     {
         cout << "max(" << x << "," << y << ")=" << y << " ";
         return y;
     }
     else
     {
         cout << "max(" << x << "," << y << ")=" << x << " ";
         return x;
     }
 }

 /**
  *  @brief Use digui to find the maxnumber of the array
  *  arraymax(a,n)=max(a[0],a[1]);       n==2;
  *  arraymax(a,n)=max(arraymax(n-2),a[n-1]);    other situation;
  *
  *  @param a
  *  @param n sizeof(a)/sizeof(a[0])
  *
  *  @return the number_value of array
  */
 int arraymax(int a[], int n)
 {
     int b;
     if (n == )
         return max(a[], a[]);
     else if(n>&&n<=)
     {   b=arraymax(a,n-);
         return max(b, a[n]);
     }
 }

 int main()
 {
     int n;
     cin >> n;
     for (int i = ; i < n; i++)
     {
         cin >> a[i];
     }
     cout << arraymax(a, n-) << endl;//0~n-1
     return ;
 }
 - c++(g++)
 #include<iostream>
 #include<algorithm>
 using namespace std;
 /**
  *  recursion && Division algorithm
 */

 /**
  *  @brief recursion algroithm
  *
  *  gcd(x,y)=y;   x%y=0;
  *  gcd(x,y)=disp;if(x%y>0)gcd(x%y,min(x,y)) else gcd(max(x,y),min(x,y));    other sitation;
  *
  *  @param x
  *  @param y
  *  @return the number_value
 */

 int gcd(int x,int y)
 {
     // int a,a1,a2,a3,a4;
     if(x%y==)
     {   cout<<"gcd("<<x<<","<<y<<") ";
         return y;
     }
     else
     {
         cout<<"gcd("<<x<<","<<y<<") ";
         // a=x%y;
         // a1=max(x,y);
         // a2=min(x,y);
         // a3=min(a,y);
         // a4=min(x,a)
         if(x/y>)
             return gcd(y,x%y);
         else
             return gcd(max(x,y),min(x,y));
     }

 }

 int main()
 {
     int x,y;
     cin>>x;cin>>y;
     cout<<gcd(x,y);
 }
 - c++(g++)
  #include <stdio.h>

 void swap(int a[], int i, int j)
 {
     // 交换数组a中元素i与元素j的值
     int tmp;
     tmp = a[i];
     a[i] = a[j];
     a[j] = tmp;
 }

 int partition(int a[], int lo, int hi)
 {
     int i = lo-, pivot = a[lo];
     swap(a, lo, hi);
     while(lo<hi)
     {
         // 循环开始的时候i指向的是小于pivot的最后的一个位置
         if(a[lo] < pivot)
         {
             i ++;
             swap(a, i, lo);
         }
         lo ++;
     }
     i ++;
     swap(a, i, hi);
     return i;
 }

 int find(int a[], int left, int right, int k)
 {
     int index;
     index = partition(a, left, right);
     if(index == k)
         return a[index];
     else if(index < k)
         return find(a, index+, right, k);
     else
         return find(a, left, right-, k);
 }

 int main()
 {
     int a[];
     int n, k, i;
     scanf("%d", &n);
     scanf("%d", &k);
     for(i=; i<n; i++)
         scanf("%d", &a[i]);
     printf("%d\n", find(a, , n-, k-));
 }
 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;

 void swap(int a,int b)
 {   int tmp;
     if(a<b)
     {   tmp=a;
         a=b;
         b=tmp;
     }   

 }
 int num(int n,int a[])
 {   int count=;
     for(int j=;j<n-;j++)
         for(int i=;i<=n-;i++)
         {   if(a[i]>a[i+])
             {   swap(a[i],a[i+]);
                 count++;
                 break;
             }
         }
     return count;
 }
 //               i==2
 // 0 1 d 1 2 2083 s 2 3 2803 s 

 int main()
 {   int n;
     cin>>n;
     int a[n];
     for(int i=;i<n;i++)
     {   cin>>a[i];
     }
     cout<<num(n,a);
 }
 - c++(g++)
 #include<stdio.h>
 #include<string.h>
 int main()
 {
     int n,i,j,max=;//max为所用箱子的数目
     int a[];//用来接收物品的
     int b[];//即用来描述物品，又用来记录装物品的箱子（看完代码后自然会理解）
     int pox[];//箱子的位置
     memset(pox,-,sizeof(pox));
     scanf("%d",&n);
     for(i=;i<n;i++)
     {
         scanf("%d",&a[i]);
         b[i]=a[i];
     }
     pox[]=;//将箱子的位置初始化为0，是为了与数组的下标匹配，更方便标记位置
     for(i=;i<n;i++)
     {
         for(j=;j<i;j++)
         {
             if(a[i]+b[j]<=)
             {
                 b[j]=b[j]+a[i];//将两个物品放在一个箱子中
                 b[i]=;//用于同步物品的信息
                 pox[i]=j;
                 break;
             }
             else
             {
                 pox[i]=i;
             }
         }
     }
     for(i=;i<n;i++)
     {
         if(pox[i]>max)
         {
             max=pox[i];
         }
     }
     for(i=;i<n;i++)
     {
         printf("%d %d\n",a[i],pox[i]+);
     }
     printf("%d",max+);
     return ;
 }
 - c++(g++)
  #include <iostream>
 using namespace std;
 int a[];
 int main()
 {
     int n, k, i, h = , j = , b;
     cin >> n >> k;
     b = n;
     for (i = ; i <= k; i++) //共有k+1个数，因为它们都是表示一个性质的，所以可以一起处理
         cin >> a[i];
     for (i = ; i <= k; i++)
         if (a[i] > n)
         {
             cout << "No Solution!\n"; //只要有一段路程大于n就无法到达
             j = ;                    //此处标记
             break;
         }
         // else
         {
             for (i = ; i <= k; i++)
             {
                 b -= a[i - ];
                 if (b < a[i])
                 {
                     h++;
                     b = n;
                 }
             }
         }
     if (!j) //利用标记法,要不然会错过h=0时的情况导致一个测试点无法通过（5分）
         cout << h << endl;
     return ;
 }
 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;
 void greedy(int n,int start[],int end[]);
 int a[],b[];
 int main()
 {
 int n;
 cin>>n;
 for(int i=;i<n;i++)
 {
 cin>>a[i]>>b[i];
 }
 sort(a,a+n);  //对开始时间进行上升排序
 sort(b,b+n); //对结束时间进行上升排序
 greedy(n,a,b);  //调用函数求最小会场数
 }
 void greedy(int n,int start[],int end[])
 {
 int j=;
 int count=;
 for(int i=;i<n;i++)
 {
 if(start[i]<end[j]){
 count++;//如果开始时间小于结束时间则另开辟一个会场
 }else{
 j++;//否则和下一个结束时间进行比较
 }
 }
 printf("%d",count);
 }
 - c++(g++)
 #include <iostream>
 #include <algorithm>
 using namespace std;

 int main()
 {
 int k;
     cin>>k;
      int a[k],b[k];
      for(int i=;i<k;i++)
     {
          cin>>a[i];
      }
      sort(a,a+k);
      for(int i=k-,j=;i>=;i--,j++)
      {
          b[j]=a[i];
      }
      int sum1=,sum2=;
      for(int i=;i<k-;i++)
      {
          a[i+]=a[i]+a[i+];
          sum1+=a[i+];
          sort(a+i,a+k);
      }
      for(int j=;j<k-;j++)
      {
          b[j+]=b[j]+b[j+];
          sum2+=b[j+];
      }
      cout<<sum2-k+<<" ";
      cout<<sum1-k+<<endl;
     return ;
  }
 - c++(g++)
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <set>
 using namespace std;
 typedef struct ab{
     int s;
     int f;
 };
 int cmp(ab a,ab b)
 {
     return a.f<b.f;
 }
 int main()
 {
     int n;
     ab x[];
     while(~scanf("%d",&n))
     {
         if(n==)
         {
             break;
         }
         for(int i=;i<n;i++)
         {
             scanf("%d %d",&x[i].s,&x[i].f);
         }
         sort(x,x+n,cmp);
         int sum=;
         int fina=x[].f;
         for(int i=;i<n;i++)
         {
             if(x[i].s>=fina)
             {
                 sum++;
                 fina=x[i].f;
             }
         }
         printf("%d\n",sum);
     }
     return ;
 }
 - c++(g++)
 #include<iostream>

 using namespace std;

     int a[][] = {,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,,

                     ,,,,,,,,,,,};
     int x1, x2, y1, y2, min1 = , t = , b[][] = {}, c[][] = {};

     int ff(int x, int y, int k)//当前的位置，k是当前的步数；
     {
         int a1, a2, a3, a4;
         if(x <  || y <  ||x >=  || y >= )
         {
             return ;
         }
         else
         {

             if(x == x2 && y == y2)
             {
                 t++;
                 if(min1 > k)    min1 = k;
                 return ;
             }
             else
             {
                 if(k >= min1)   return ;
                 if(a[x][y] == )
                 {
                     if(b[x][y] == )
                     {
                         if(c[x][y] == )
                         {
                             b[x][y] = ;
                             a1 = ff(x+, y, k+);
                             a2 = ff(x, y+, k+);
                             a3 = ff(x-, y, k+);
                             a4 = ff(x, y-, k+);
                             b[x][y] = ;
                             if(a1 == &&a2 == &&a3 == &&a4 == )
                             {
                                 c[x][y] = ;
                                 return ;
                             }
                             else    return ;
                         }
                         return ;
                     }
                     else    return ;
                 }
                 else
                 {
                     return ;
                 }
             }
         }
     }

     int main()
     {
         int i, j;
         cin>>x1>>y1>>x2>>y2;
         if(a[x2][y2] == )    cout<<"";
         else
         {
             ff(x1, y1, );
             if(t == )  cout<<"";
             else    cout<<min1-;
         }

         return ;
      }
 - c++(g++)
 #include<iostream>

     using namespace std;

     int a[], n, t, b[] = {}, z = ;
     int c[];
     void print(int k)
     {
         int i;
         z++;
         for(i = ; i <= k; i++)
         {
             cout<<c[i]<<" ";
         }
         cout<<endl;
     }

     int ff()
     {
         int i = , sum = , j = ;
         while(i > )
         {
             if(b[i] == )
             {
                 b[i] = ;
                 sum += a[i];
                 c[j] = a[i];
                 j++;
                 i++;
                 if(sum == t)    return j;
                 if(sum > t)
                 {
                     sum -= a[i-];
                     b[i-] = ;
                     j--;
                 }
                 if(i > n)
                 {
                     i = n - ;
                     if(b[n] == )
                     {
                         sum -= a[n];
                         b[n] = ;
                         j--;

                     }    

                     while(b[i] == )
                     {
                         i--;
                         if(i < )    return ;
                     }
                     j--;
                     sum -= a[i];
                     b[i] = ;
                     i++;
                 }
             }
         }
         return ;
     } 

     int main()
     {
         int i, j, tol = ;
         cin>>n>>t;
         for(i = ; i <= n; i++)
         {
             cin>>a[i];
             tol += a[i];
         }
         if(tol >= t)
         {
             j = ff();
             if(j)
             {
                 print(j-);
             }
             else    cout<<"No Solution!";
         }
         else        cout<<"No Solution!";
         return ;
     }
 7.17 c++(g++)
 #include<iostream>
 #include<cstdlib>
     using namespace std;

     int n, a[], x, b[] = {}, Min = ;
     int compare(void const * q, void const * p)
     {
         return *(int *)q - *(int *)p;
     }

     int ff(int k)
     {
         int i, Max = , t;
         if(k <= n)
         {
             for(i = ; i <= x; i++)
             {
                 if((b[i] + a[k]) > Min)
                     return ;
                 b[i] += a[k];

                 t = ff(k+);
                 //if(t == 0)    return 0;
                 b[i] -= a[k];
             }
         }
         if(k > n)
         {
             for(i = ; i <= x; i++)
             {
                 if(b[i] > Max)    Max = b[i];
             }
             if(Min > Max)   Min = Max;
         }
     }

     int main()
     {
         int i;
         cin>>n>>x;
         for(i = ; i <= n; i++)
         {
             cin>>a[i];
         }
         qsort(&a[], n, sizeof(int), compare);
         ff();
         cout<<Min;
         return ;
     }
 7.18 c++(g++)
 #include<iostream>

     using namespace std;

     int a[], n, t, b[] = {}, z = ;

     void print(int k)
     {
         int i;
         z++;
         for(i = ; i < k; i++)
         {
             if(i == )  cout<<b[i];
             else    cout<<" "<<b[i];
         }
         cout<<endl;
     }

     void ff(int k, int w, int num)//k是前一个数的下表，w是当前要存入的下标 ，num是当前总数
     {
         int i;
         if(num <= t)
         {
             if(num == t)
             {
                 print(w);
             }
             else
             {
                 for(i = k+; i <= n; i++)
                 {
                     b[w] = a[i];
                     ff(i, w+, num+a[i]);
                 }
             }
         }
     }

     int main()
     {
         int i;
         cin>>n;
         for(i = ; i <= n; i++)
             cin>>a[i];
         cin>>t;
         ff(, , );
         if(z == )  cout<<"None";
         return ;
     }
 7.19 c++(g++)
 #include <stdio.h>
 #define inf 0x3f3f3f3f

 int n,ans;
 int c[][];
 int vis[];

 void dfs(int i,int sum)//i是行号
 {
     if(sum>ans) //剪枝
         return ;
     if(i==n+ && sum<ans)
     {
         ans=sum;
         return ;
     }
     for(int j=;j<=n;j++)
     {
         if(!vis[j])//遍历第i行 没有被遍历过列号j 的元素
         {
             vis[j]=;
             dfs(i+,sum+c[i][j]);
             vis[j]=;
         }
     }
 }

 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             scanf("%d",&c[i][j]);
     ans=inf;
     dfs(,);
     printf("%d\n",ans);
     return ;
 }
 - c++(g++)
 #include<stdio.h>
 #define MAX 100
 #define max(x,y) ((x)>(y)?(x):(y))

 int dp[MAX];
 int ans = ;

 void solve(int a[],int n)
 {
     int i,j;
     for(i=;i<n;i++)
     {
         dp[i]=;
         for(j=;j<i;j++)
         {
             if(a[i]>a[j])
                 dp[i]=max(dp[i],dp[j]+);
         }
     }
     ans=dp[];
     for(i=;i<n;i++)
         ans=max(ans,dp[i]);
 }

 int main()
 {
     int n;
     scanf("%d",&n);
     int a[n];
     for(int i=;i<n;i++)
         scanf("%d",&a[i]);
     solve(a,n);
     printf("%d",ans);
     return ;
 }
 - c++(g++)
 #include<stdio.h>
 #include"cstdio"
 #include"iostream"
 #include"string.h"
 #include"algorithm"
 using namespace std;
 char str[];
 int dp[][];
 int main()
 {

     memset(dp,,sizeof(dp));
     char str1[];
     scanf("%s",str);
     int len=strlen(str);
     int j=len-;
     for(int i=;i<len;i++)
         str1[j--]=str[i];
     for(int i=;i<=len;i++)
     {
         for(int j=;j<=len;j++)
             if(str[i-]==str1[j-])
                dp[i][j]=max(dp[i][j],dp[i-][j-]+);
             else
                 dp[i][j]=max(dp[i-][j],dp[i][j-]);
     }
     printf("%d\n",len-dp[len][len]);
 }
 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;
 long max3(long a,long b,long c)
 {   if(a<b) a=b;
     if(a>c) return a;
     else return c;
 }
 long maxSubSum(int a[],int left,int right)
 {   int i,j;
     long maxLeftSum,maxRightSum;
     long maxLeftBorderSum,leftBorderSum;
     long maxRightBorderSum,rightBorderSum;
     if(left==right)
     {   if(a[left]>)
             return a[left];
         else
             return ;
     }
     int mid=(left+right)/;
     maxLeftSum=maxSubSum(a,left,mid);
     maxRightSum=maxSubSum(a,mid+,right);
     maxLeftBorderSum=,leftBorderSum=;
     for(i=mid;i>=left;i--)
     {   leftBorderSum+=a[i];
         if(leftBorderSum>maxLeftBorderSum)
             maxLeftBorderSum=leftBorderSum;
     }
     maxRightBorderSum=,rightBorderSum=;
     for(j=mid+;j<=right;j++)
     {   rightBorderSum+=a[j];
         if(rightBorderSum>maxRightBorderSum)
             maxRightBorderSum=rightBorderSum;
     }
     return max3(maxLeftSum,maxRightSum,maxLeftBorderSum+maxRightBorderSum);
 }

 int main()
 {   int n;
     cin>>n;
     int a[n];
     for(int i=;i<n;i++)
     {   cin>>a[i];
     }
     cout<<maxSubSum(a,,n-)<<endl;
 }
 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;
 int main() {
     int n, k;
     while (~scanf("%d,%d", &n, &k)) {
         int dp[][];
         int i, j;
         for (i = ; i <= n; i++) {
             for (j = ; j <= k; j++) {
                 if (j ==  || i == )
                     dp[i][j] = ;
                 else if (j == i) {
                     dp[i][j] = dp[i][j - ] + ;
                 }
                 else if (i < j) {
                     dp[i][j] = dp[i][i];
                 }
                 else if (i > j) {
                     dp[i][j] = dp[i][j - ] + dp[i - j][j];
                 }
             }
         }
         printf("%d\n", dp[n][k]);
     }
     return ;
 }
 - c++(g++)
 #include<iostream>
 using namespace std;

 int f(int n)

 {

     int num1 = , num2 = , num3 = , i = ;

     if (n <= )

     {

         return num1;

     }

     for (i = ; i < n; i++)

     {

         num3 = num1 + num2;

         num1 = num2;

         num2 = num3;

     }

     return num3;

 }

 int main()
 {

     int n,i;
     cin>>n;
     int a[n];
     for(i=;i<n;i++)
         cin>>a[i];
     for(i=;i<n;i++)
         cout<<f(a[i])<<endl;
     return ;

 }
 - c++(g++)
 #include<stdio.h>
 int father[],num[],tmp,vis[],cnt[];
 int Find(int x)
 {
     if(x != father[x])
       father[x] = Find(father[x]);

     return father[x];
 }
 int main(void)
 {
     int N,M,flag,fcur,ans=;
     scanf("%d%d",&N,&M);
     for(int i=;i<=N;i++)
      father[i] = i;

     for(int i = ;i<=M;i++)
     {
         int cnt,lf;
         scanf("%d",&cnt);
         flag = ;
         for(int j=;j<=cnt;j++){
             int cur;
             scanf("%d",&cur);
             if(num[cur]==){
                 if(j==){
                    num[cur] = cur;
                    lf = father[cur];
                 }
                 num[cur]    = cur;
                 father[cur] = lf;

              }
             else  {
                      if(j==)
                        lf = Find(cur);
                      int fcur = Find(cur);
                        father[fcur] = lf;
                   }
         }

     }

     for(int i=;i<=N;i++){ 

         int fx = Find(i);
         cnt[fx]++;

         if(ans < cnt[fx])
         ans = cnt[fx];

     }

     printf("%d\n",ans);

     return ;
 }
 - c++(g++)
 #include<iostream>
 #include<cstring>
 using namespace std;
 typedef struct Node{
     char sex;
     int fId;
     int mId;
 }Node;
 Node p[];
 int flag,visited[];
 void f(int a,int sum){
     if(sum >  || a == - || a == )//如果代数大于5代,或者a==-1,说明都不在人世,
                                     //或者a==0说明没有被赋值,直接返回
         return;
     visited[a]++;//记录被访问的次数
     if(visited[a] >= )//如果五代以内的同一个人被访问超过2次,说明在五代之内有共同的祖先
         flag = ;
     f(p[a].fId,sum + );//递归调用,a的父亲,代数+1
     f(p[a].mId,sum + );//递归调用,a的母亲,代数+1
     return;
 }
 int main(){
     int n,selfId,fId,mId,k,a,b;
     char c;
     scanf("%d",&n);
     for(int i = ;i < n;i++){
             scanf("%d %c%d%d",&selfId,&c,&fId,&mId);
             p[selfId].sex = c;//记录自己的性别
             p[selfId].fId = fId;//记录父亲的Id
             p[selfId].mId = mId;
             p[fId].sex = 'M';//记录自己父亲的性别,否则,可能会漏掉
             p[mId].sex = 'F';//记录自己母亲的性别,否则,可能会漏掉
     }
     scanf("%d",&k);
     while(k--){
         flag = ;//标记变量,默认为1
         memset(visited,,sizeof(visited));//每循环一次,必须进行一次初始化
         scanf("%d%d",&a,&b);
         if(p[a].sex == p[b].sex){
             printf("Never Mind\n");
             continue;
         }
         f(a,);//以a为起点,代数为一代,进行寻找
         f(b,);//以a为起点,代数为一代,进行寻找
         if(flag)
             printf("Yes\n");
         else
             printf("No\n");
     }
     return ;
 }
 - c++(g++) ×

 - c++(g++)
 #include<bits/stdc++.h>
 using namespace std;
 const int MAXN = 1e5 + ;
 int  d[MAXN];
 vector<int>edge[MAXN];
 void dfs(int x,int o)
 {
     d[x]=o;
     for(int i=;i<edge[x].size();i++)
         dfs(edge[x][i],o+);
 }
 int main()
 {
     int n,k,x,s;
     cin>>n;
     s=(n+)*n/;
     for(int i=;i<=n;i++)
     {
         cin>>k;
         while(k--)
         {
             cin>>x;
             s-=x;
             edge[i].push_back(x);
         }
     }
     dfs(s,);
     s=;
     for(int i=;i<=n;i++)
         if(d[s]<d[i])
             s=i;
     cout<<s<<endl;
     return ;
 }
 - c++(g++)
 #include <bits/stdc++.h>

 using namespace std;
 const int maxn=+;
 const int INF=0x3f3f3f3f;
 int V,E,s,t,num=;
 int cost[maxn][maxn];
 int d[maxn];
 int prev1[maxn];
 int value[maxn];
 int roadnum[maxn];
 int amount[maxn];
 bool used[maxn];

 void dijkstra(int s)
 {
     memset(d,INF,sizeof(d));
     memset(used,false,sizeof(used));
     memset(prev1,-,sizeof(prev1));
     memset(roadnum,,sizeof(roadnum));
     memset(amount,,sizeof(amount));
     d[s]=;
     roadnum[s]=;
     amount[s]=value[s];

     while(true)
     {
         int v=-;
         for(int u=;u<V;u++)
         {
             if(!used[u]&&(v==-||d[u]<d[v])) v=u;
         }

         if(v==-) break;
         used[v]=true;

         for(int u=;u<V;u++)
         {

             if(d[u]>d[v]+cost[v][u])
             {
                 d[u]=d[v]+cost[v][u];
                 amount[u]=amount[v]+value[u];
                 roadnum[u]=roadnum[v];
                 prev1[u]=v;
                 //cout<<"gg1:     "<<amount[u]<<"    "<<u<<"    "<<v<<endl;
             }
             else if(d[u]==d[v]+cost[v][u])
             {
                 roadnum[u]+=roadnum[v];
                 if(amount[u]<amount[v]+value[u])
                 {
                     amount[u]=amount[v]+value[u];
                     prev1[u]=v;
                     //cout<<"gg2:     "<<amount[u]<<"    "<<u<<"    "<<v<<endl;

                 }

             }

         }
     }
 }

 int main()
 {
     scanf("%d %d %d %d",&V,&E,&s,&t);
     for(int i=;i<V;i++) memset(cost[i],INF,sizeof(cost[i]));

     for(int i=;i<V;i++) scanf("%d",&value[i]);
     for(int i=;i<E;i++)
     {
         int a,b,c; scanf("%d %d %d",&a,&b,&c);
         cost[a][b]=cost[b][a]=c;
     }
     dijkstra(s);

     int prevt[maxn];
     int pos=;

     int tt=t;
     for(;tt!=-;tt=prev1[tt])
     {
         prevt[pos++]=tt;
     }

     printf("%d %d\n",roadnum[t],amount[t]);
     for(int i=pos-;i>=;i--)
     {
         if(i) printf("%d ",prevt[i]);
         else printf("%d",prevt[i]);
     }

     return ;
 }
 - c++(g++)
 #include<iostream>
 #include<cstring>

 using namespace std;
 int f[],book[];

 struct edge{
     int x,y;
 };
 edge edges[];
 int n,m,sum;
 int find(int x)
 {
     return f[x]<?x:f[x]=find(f[x]);
 }
 void merge(int x,int y)
 {
     int rx=find(x);
     int ry=find(y);
     if(rx!=ry)
     {
         f[rx]+=f[ry];
         f[ry]=rx;
     }
 }
 int main()
 {
     cin>>n>>m;
     memset(f,-,sizeof(f));
     for(int i=;i<=m;i++)
     {
         int x,y;cin>>x>>y;
         edges[i]=edge{x,y};
         merge(x,y);
     }
     for(int i=;i<n;i++)
     {
         if(f[i]<)sum++;
     }

     int k;cin>>k;

     for(int i=;i<=k;i++)
     {
         int cnt=;
         memset(f,-,sizeof(f));
         int x;cin>>x;book[x]=;
         for(int j=;j<=m;j++)
         {
             if(!book[edges[j].x]&&!book[edges[j].y])
             {
                 merge(edges[j].x,edges[j].y);
             }
         }
         for(int i=;i<n;i++)
         {
             if(!book[i]&&f[i]<)cnt++;
         }
         //sum=cnt;

         if(cnt>sum) cout<<"Red Alert: City "<<x<<" is lost!"<<endl;
         else cout<<"City "<<x<<" is lost."<<endl;
         sum=cnt;
         if(i==n)cout<<"Game Over."<<endl;
     }
     return ;
 }
 - c++(g++)
 #include <bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int INF=0x3f3f3f3f;
 const int maxn=1e3+;
 struct node
 {
     int x,y;
 }a[maxn];

 int n,d;
 int di[maxn][maxn],via[maxn][maxn];
 vector<int> apos;
 stack<int> first;

 void DFS(int i,int j)
 {
     if(via[i][j]==-)
     {
         if(i!=)
           first.push(i);
     }
     else if(via[i][j]!=INF)
     {
         DFS(via[i][j],j);
         DFS(i,via[i][j]);
     }

     return ;
 }

 int main()
 {
     scanf("%d %d",&n,&d);

     if(d>=)
     {
         printf("");
         return ;
     }

     for(int i=;i<=n;i++)
     {
         scanf("%d %d",&a[i].x,&a[i].y);

         if(abs(a[i].x)+d>=||abs(a[i].y)+d>=)
         {
             apos.push_back(i);
         }
     }
     a[].x=a[].y=;

     memset(di,INF,sizeof(di));
     memset(via,INF,sizeof(via));

     for(int i=;i<=n;i++)
     {
         di[i][i]=;
         for(int j=i+;j<=n;j++)
         {
             double x=;
             if(i==) x=7.5;

             double tx=a[i].x-a[j].x;
             double ty=a[i].y-a[j].y;
             double td=d+x;

             if(tx*tx+ty*ty<=td*td)
             {
                 di[i][j]=di[j][i]=;
                 via[i][j]=via[j][i]=-;
             }
         }
     }

     for(int k=;k<=n;k++)
     {
         for(int i=;i<=n;i++)
         {
             if(di[i][k]==INF) continue;
             for(int j=;j<=n;j++)
             {
                 if(di[k][j]==INF) continue;
                 if(di[i][j]>di[i][k]+di[k][j])
                 {
                     di[i][j]=di[j][i]=di[i][k]+di[k][j];
                     via[i][j]=via[j][i]=k;
                 }
             }
         }
     }

     int ans=INF;
     for(int i=;i<apos.size();i++)
         ans=min(ans,di[][apos[i]]);

     if(ans==INF)
     {
         printf("");
         return ;
     }

     int pos=-,dmin=INF;
     for(int i=;i<apos.size();i++)
     {
         if(ans==di[][apos[i]])
         {
             DFS(,apos[i]);
             int t=first.top();
             double tx=a[t].x;
             double ty=a[t].y;

             if(dmin>tx*tx+ty*ty)
             {
                 pos=apos[i];
                 dmin=tx*tx+ty*ty;
             }

             while(!first.empty()) first.pop();
         }
     }

     first.push(pos);
     DFS(,pos);
     printf("%d\n",ans+);

     while(!first.empty())
     {
         int t=first.top(); first.pop();
         printf("%d %d\n",a[t].x,a[t].y);
     }

     return ;
 }
 - c++(g++)
 #include<iostream>
 #include<vector>
 #include<map>
 using namespace std;

 const int INF = 0x3f3f3f3f;
 const int maxn =  + ;
 map<string,int> mp;                 

 int n, k, w;
 struct edge{
     int to,cost;
 };
 vector <edge> G[maxn];
 int num[maxn];

 int dis[maxn];
 int cnt[maxn];
 int sumnum[maxn];
 int pred[maxn];
 int cntshort[maxn];
 int book[maxn];
 vector <int> ljd;
 int s, des;

 void dijsk()
 {

     for(int i = ;i < n;i++)
         dis[i] = INF;

     dis[s] = ;
     cntshort[s] = ;
     book[s] = ;

     for(int i = ;i < G[s].size();i++)
     {
         int next = G[s][i].to;
         dis[next] = G[s][i].cost;       

         cntshort[next] = ;
         sumnum[next] = num[next];
         pred[next] = s;
     }

     int min, minindex;
     for(int i = ;i <= n - ;i++)
     {
         min = INF;
         minindex = ;
         for(int i = ;i < n;i++)
         {
             if(dis[i] < min && book[i] != )
             {
                 min = dis[i];
                 minindex = i;
             }
         }
         book[minindex] = ;

         for(int i = ;i < G[minindex].size();i++)
         {
             edge& e = G[minindex][i];
             int d2 = dis[minindex] + e.cost;    

             if(dis[e.to] > d2)
             {
                 dis[e.to] = d2;
                 pred[e.to] = minindex;
                 cnt[e.to] = cnt[minindex] + ;
                 sumnum[e.to] = sumnum[minindex] + num[e.to];
                 cntshort[e.to] = cntshort[minindex];
             }
             else if(dis[e.to] == d2)
             {
                 cntshort[e.to] += cntshort[minindex];
                 if(cnt[e.to] < cnt[minindex] + )
                 {

                     pred[e.to] = minindex;
                     cnt[e.to] = cnt[minindex] + ;
                     sumnum[e.to] = sumnum[minindex] + num[e.to];
                 }
                 else if(cnt[e.to] == cnt[minindex] + )
                 {

                     if(sumnum[e.to] < sumnum[minindex] + num[e.to])
                     {
                         sumnum[e.to] = sumnum[minindex] + num[e.to];
                         pred[e.to] = minindex;
                     }
                 }
             }
         }

     }
 }

 void dfs(int *p, int x,vector <int>& a)
 {

     if(x == s)
     {
         a.push_back(x);
         return ;
     }
     dfs(p, p[x], a);
     a.push_back(x);
 }

 int main()
 {
     string city[maxn];
     string city1, city2;
     cin >> n >> k >> city1 >> city2;        

     city[] = city1;
     mp[city1] = ;                      

     for(int i = ;i < n;i++)
     {
         cin >> city[i] >> w;
         mp[city[i]] = i;
         num[i] = w;
     }

     s = ;
     des = mp[city2];                

     int u, v;

     for(int i = ;i < k;i++)
     {
         cin >> city1 >> city2 >> w;
         u = mp[city1];  v = mp[city2];  

         G[u].push_back((edge){v, w});
         G[v].push_back((edge){u, w});
     } 

     dijsk();
     dfs(pred, des, ljd);
     cout<<city[];
     for(int i = ;i<ljd.size();++i){
         cout<<"->"<<city[ljd[i]];
     }
     printf("\n%d %d %d",cntshort[des],dis[des],sumnum[des]);
     return ;
 }
 - c++(g++)
 #include <stdio.h>
 #define MAXN 100

 typedef struct
 {
     int arcs[MAXN][MAXN];
     int vexnum,arcnum;
 }AMGraph;

 int main()
 {
     int n;
     AMGraph G;

     scanf("%d %d %d",&G.vexnum, &n, &G.arcnum );
     int safecity[MAXN];
     for(int i=;i<n;i++)
     {
         scanf("%d",&safecity[i]);
     }
     for(int i=;i<G.vexnum;i++)
     {
         for(int j=;j<G.vexnum;j++)
         {
             G.arcs[i][j]=;
         }
     }
     for(int i=;i<G.arcnum;i++)
     {
         int x,y;
         scanf("%d %d",&x,&y);
         G.arcs[x][y]=;
         G.arcs[y][x]=;
     }
     int now,destination,flag=;
     scanf("%d %d",&now,&destination);
     for(int i=;i<n;i++)
     {
         if(destination==safecity[i])
         {
             flag=;
             break;
         }
     }
     if(G.arcs[now][destination]==)
     {
         if(flag)
         printf("The city %d can arrive safely!\n",destination);
         else
         {
             printf("The city %d is not safe!\n",destination);

         }
     }
     else
     {
         if(flag)
         printf("The city %d can not arrive safely!\n",destination);
         else printf("The city %d is not safe!\n",destination);
     }
     return ;
 }
 - c++(g++)
 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<queue>
 #include<math.h>
 using namespace std;
 const int maxm = ;
 const int maxn = ;
 const int INF = ;
 int flag[maxm][maxm], key[maxm*maxm], dis[maxn][maxm];
 int id[maxm][maxm], vis[maxm*maxm], head[maxm*maxm], map[maxm][maxm];
 int dx[] = { ,,,- };
 int dy[] = { ,-,, };
 struct node
 {
     int v, w, next;
 }edge[maxm*maxm * ];
 struct point
 {
     int x, v;
     point(int a, int b) :x(a), v(b) {}
     point() {}
 };
 int n, m, s, t, cnt;
 void init()
 {
     cnt = , s = , t = n*m;
     memset(head, -, sizeof(head));
     memset(map, -, sizeof(map));
     memset(key, , sizeof(key));
 }
 void add(int u, int v, int w)
 {
     edge[cnt].v = v, edge[cnt].w = w;
     edge[cnt].next = head[u], head[u] = cnt++;
 }
 int bfs()
 {
     queue<point>q;
     memset(dis, 0x3f, sizeof(dis));
     dis[][s] = ;
     q.push(point(, s));
     while (!q.empty())
     {
         point now = q.front();q.pop();
         int u = now.v;
         dis[now.x | key[u]][u] = min(dis[now.x | key[u]][u], dis[now.x][u]);
         now.x |= key[u];
         for (int i = head[u];i != -;i = edge[i].next)
         {
             int v = edge[i].v;
             if ((now.x&edge[i].w) == edge[i].w)
             {
                 if (dis[now.x][v] > dis[now.x][u] + )
                 {
                     dis[now.x][v] = dis[now.x][u] + ;
                     q.push(point(now.x, v));
                 }
             }
         }
     }
     int ans = INF;
     for (int i = ;i < maxn;i++)
         ans = min(ans, dis[i][t]);
     if (ans == INF) return -;
     return ans;
 }
 int main()
 {
     int  i, j, k, sum, p, len = ;
     int x1, x2, y1, y2, z, u, v;
     scanf("%d%d%d%d", &n, &m, &p, &k);
     init();
     for (i = ;i <= n;i++)
         for (j = ;j <= m;j++)
             id[i][j] = ++len;
     for (i = ;i <= k;i++)
     {
         scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &z);
         u = id[x1][y1], v = id[x2][y2];
         map[u][v] = map[v][u] = z;
         if (z) add(u, v,  << z), add(v, u,  << z);
     }
     scanf("%d", &k);
     for (i = ;i <= k;i++)
     {
         scanf("%d%d%d", &x1, &y1, &z);
         key[id[x1][y1]] |=  << z;
     }
     for (i = ;i <= n;i++)
     {
         for (j = ;j <= m;j++)
         {
             u = id[i][j];
             for (k = ;k < ;k++)
             {
                 int x = i + dx[k];
                 int y = j + dy[k];
                 v = id[x][y];
                 if (map[u][v] == - && id[x][y])
                     add(u, v, );
             }
         }
     }
     printf("%d\n", bfs());
     return ;
 }
 - c++(g++) ×

 - c++(g++) ×

 - c++(g++)
 #include <stdio.h>
 #include <string.h>
 int main()
 {
     char str[][],t[],str1[];
     int i,j,n=;
     while()
     {
         scanf("%s",str1);
         if(str1[]=='#')
         {
             break;
         }
         else
         {
         strcpy(str[n],str1);
         n++;
         }
     }
     for(i=;i<n-;i++)
         for(j=;j<n-i-;j++)
         {
             if(strlen(str[j])>strlen(str[j+]))
             {
                strcpy(t,str[j]);
                strcpy(str[j],str[j+]);
                strcpy(str[j+],t);
             }
         }
     for(i=;i<n;i++)
     {
         printf("%s ",str[i]);
     }
     return ;
 }
 - c++(g++)
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<climits>
 using namespace std;
 bool cmp(double a,double b){
     return a > b;
 }
 int main(){
     int n,k,m,a,mx,mn,kx;
     double sum,arr[];
     scanf("%d%d%d",&n,&k,&m);
     memset(arr,,sizeof(arr));
     kx = ;
     for(int i = ;i < n;i++){
         mx = INT_MIN,mn = INT_MAX,sum = ;
         for(int d = ;d < k;d++){
             scanf("%d",&a);
             mx = max(a,mx);
             mn = min(a,mn);
             sum += a;
         }
         sum = sum - mx - mn;
         arr[kx++] = sum / (k - );
     }
     sort(arr,arr + kx,cmp);
     for(int i = m - ;i >= ;i--){
         if(i)
             printf("%.3lf ",arr[i]);
         else
             printf("%.3lf\n",arr[i]);
     }
     return ;
 }

 - c++(g++)
 #include <iostream>
 using namespace std;
 int main()
 {
     int n,i,j,k,p;
     int a[][];
     cin>>n;
     for(i=;i<=n;i++)
     {
         a[i][i]=;
     }
     for(i=;i<=n;i++)
     {
         for(j=i+;j<=n;j++)
         {
             cin>>a[i][j];
         }
     }
     for(i=;i<=n;i++)
     {
         for(j=i+;j<=n;j++)
         {
             k=j-i;
             for(p=k;p<j;p++)
             {
                 if(a[k][j]>a[k][p]+a[p][j])
                 a[k][j]=a[k][p]+a[p][j];
             }
         }
     }
     cout<<a[][n]<<endl;
     return ;
 }
 - c++(g++)
 #include<iostream>
 #include<queue>
 using namespace std;
 int main()
 {
     int n,m;
     priority_queue< int, vector<int>, greater<int> > q;
     cin>>n;
     for(int i=;i<n;i++)
     {
         cin>>m;
         q.push(m);
     }
     int sum =;
     while(!q.empty())
     {
         int x = q.top();
         q.pop();
         if(q.empty())
             break;
         int y = q.top();
         q.pop();
         x+=y;
         sum+=x;
         q.push(x);
     }
     cout<<sum<<endl;
     return ;
 }