SGU 乱乱开

本解题报告 乱抄，乱写，随性随心，不喜多喷！

SGU 142：

思路：一个string的字串不会超过2^20个,我们枚举出来就好了。

我出错点：数组RE

 #include<stdio.h>
 #include<math.h>
 #include<algorithm>
 #include<string.h>
 #include<string>
 #include<iostream>
 #include<set>
 #include<map>
 #include<vector>

 using namespace std;
 typedef long long ll;

 #define N 566666

 int n;
 char s[N];
 bool  b[<<];
 char ss[];

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

    memset(b,false,sizeof(false));

    int tot=<<len;

    for (int i=;i<n;i++)
    {
       int num=;
       for (int j=;j<len&&i+j<n;j++)
       {
               if (s[i+j]=='a')
               num<<=;
               else num=num*+;
          b[num]=true;
       }
    }

    int pos;

    for (int i=;i<tot;i++)
    if (!b[i])
    {
        pos=i;
        break;
    }

    int num=floor(log(pos)/log());

    printf("%d\n",num);
    int tmp=num;

    while (pos>)
    {
      if (pos&) ss[tmp--]='b';
      else ss[tmp--]='a';
      pos/=;
    }

   for (int i=;i<=num;i++)
   printf("%c",ss[i]);

   printf("\n");
    return ;
 }

View C:ode

SGU 146 你WA的话，精度 ，精度

SGU 172:二分图染色，然后二分图的一边

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<iostream>
 #include<math.h>
 #include<stack>
 #include<string>
 #include<map>
 #include<set>
 #include<vector>

 using namespace std;
 typedef long long ll;
 #define N 102222

 vector<int>mp[];
 int vis[];

 int col[];

 int ans[];

 int tmp=;
 int flag=;
 void  dfs(int x)
 {
     vis[x]=;
     for (int i=;i<mp[x].size();i++)
     {
         int v=mp[x][i];
         if (!vis[v])
         {
             col[v]=-col[x];
             dfs(v);
         }
         else
         {
             if (col[v]==col[x])
             {
                 flag=;
                 return ;
             }
         }
     }
 }

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

     while (m--)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         mp[x].push_back(y);
         mp[y].push_back(x);
     }

     for (int i=;i<=n;i++)
     if (!vis[i])
     {
         col[i]=;
         dfs(i);
         if (flag)
         {
           puts("no");
           return ;
         }
     }

     puts("yes");

     for (int i=;i<=n;i++)
     if (col[i]==)
     {
         ans[++tmp]=i;
     }

     printf("%d\n",tmp);
     for (int i=;i<tmp;i++)
     printf("%d ",ans[i]);

     printf("%d\n",ans[tmp]);

     return ;
 }

SGU 149:  经典题，求任意点到树中任意一点的最长距离。

一遍DFS求出一个点，子树在树中的最远和次远距离;

对每个点 求出其父节点的最远距离。dp[father[u]]= max(dp[father[u]]，dp[u].first(子树最长）+e.val);（father[u]不再u 的最长路径上)

否则：dp[father[u]]= max(dp[father[u]]，dp[u].first(子树次长）+e.val);（father[u]再u 的最长路径上)

 #include<stdio.h>
 #include<math.h>
 #include<algorithm>
 #include<string.h>
 #include<string>
 #include<iostream>
 #include<set>
 #include<map>
 #include<vector>

 using namespace std;
 typedef long long ll;

 #define N 11111
 int head[N];
 struct node
 {
     int v,c,next;
 }e[N<<];
 int tot;

 struct node2
 {
     int idx,val;
 }dp[N][],p;

 void init()
 {
     tot=;
     memset(head,-,sizeof(head));
 }

 void add(int u,int v,int c)
 {
    e[tot].v=v;
    e[tot].c=c;
    e[tot].next=head[u];

    head[u]=tot++;
 }

 void dfs_son(int u,int pre)
 {
     for (int i=head[u];i!=-;i=e[i].next)
     {
         int v=e[i].v;
         int c=e[i].c;
         if (v==pre) continue;
         dfs_son(v,u);
         p.val=dp[v][].val+c;
         p.idx=v;

         if (p.val>dp[u][].val)
         {
             dp[u][]=dp[u][];
             dp[u][]=p;
         }

         else if (p.val>dp[u][].val)
         {
             dp[u][]=p;
         }
     }
 }

 void dfs_father(int u,int pre)
 {
     for (int i=head[u];i!=-;i=e[i].next)
     {
         int v=e[i].v;
         int c=e[i].c;
         if (v==pre) continue;
         int first=dp[u][].val;
         int second=dp[u][].val;

         int idx=dp[u][].idx;

         if (idx==v) dp[v][].val = max(dp[v][].val,second+c);
         else dp[v][].val = max(dp[v][].val,first+c);   

         dp[v][].val=max(dp[v][].val,dp[u][].val+c);

         dfs_father(v,u);
      }
  }

 int main()
 {

     int n;
     scanf("%d",&n);
     init();

     for (int i=;i<=n;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
     //    add(i,x,y);
         add(x,i,y);
     }
     dfs_son(,-);
     dfs_father(,-);
     for (int i=;i<=n;i++)
     printf("%d\n",max(dp[i][].val,dp[i][].val));
      return ;
 }

SGU 169: 脑洞题，真心脑洞大开题；看到这么大数位的k,就知道有规律，但是想到的还是太浅太浅，我只是往奇偶数上想了

引用一篇blog:  http://www.cppblog.com/willing/archive/2010/05/04/114304.html

SGU 143

小型树形DP，如果子树大于0,那么父节点加上就好了，

注意：有一个节点的情况，比如第二个test

 #include<stdio.h>
 #include<algorithm>
 #include<math.h>
 #include<vector>
 #include<string.h>
 #include<string>
 #include<set>
 #include<iostream>
 using namespace std;
 typedef long long ll;

 #define N 26666
 vector<int> mp[N];

 int a[N];
 int n;
 int dp[N];
 int vis[N];

 void dfs(int u)
 {
    vis[u]=;
    for (int i=;i<mp[u].size();i++)
     {
         int v=mp[u][i];
         if (!vis[v])
         {
             dfs(v);
             if (dp[v]>) dp[u]+=dp[v];

         }
     }

 }

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

    for (int i=;i<=n;i++) scanf("%d",&a[i]),dp[i]=a[i];

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

     dfs();

     int ans=-;

     for (int i=;i<=n;i++)
     ans=max(ans,dp[i]);
     printf("%d\n",ans);
     return ;
 }

SGU 144:

概率题，一个人等待的时间是（Y-X）*60，如果先到的人等待了Zminute,就会离开，求不会离开的概率

画个矩形图。

SGU 134:

求树的重心；

要么是某一个子树的最大节点，要么是包含根的子树；

 #include<stdio.h>
 #include<algorithm>
 #include<math.h>
 #include<vector>
 #include<string.h>
 #include<string>
 #include<set>
 #include<map>
 #include<iostream>
 #include<set>
 using namespace std;
 typedef long long ll;
 #define N 33333
 vector<int>mp[N];
 int sum[N];
 int a[N];
 int dp[N];

 void dfs(int u,int pre)
 {
   for (int i=;i<mp[u].size();i++)
   {
       int v=mp[u][i];
       if (v==pre) continue;
       dfs(v,u);
       sum[u]+=sum[v];
   }
   sum[u]++;
 }

 int t=;
 int ans=;

 void cal(int u,int pre)
 {
    int tmp=sum[u];
         dp[u]=;
    for (int i=;i<mp[u].size();i++)
    {
               int v=mp[u][i];
            if (v==pre) continue;
               cal(v,u);
               dp[u]=max(dp[u],sum[v]);
    }

   dp[u]=max(dp[u],sum[]-sum[u]);
    if (dp[u]==ans)
    {
        ++t;
        a[t]=u;
    }
    else if (dp[u]<ans)
    {
        t=;
        ans=dp[u];
        a[t]=u;
    }
 }

 int main()
 {
     int n;
     scanf("%d",&n);
     for (int i=;i<n;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         mp[x].push_back(y);
         mp[y].push_back(x);
     }
     dfs(,-);
     //for (int i=1;i<=n;i++) printf("%d ",sum[i]);
     cal(,-);
     printf("%d %d\n",ans,t);
     sort(a+,a+t+);
     for (int i=;i<t;i++) printf("%d ",a[i]);
     printf("%d\n",a[t]);
     return ;
 }

SGU 174:

只要判断当前点是否在一个集合中，不包括自己

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <set>
 #include <map>
 #include <string>
 #include <math.h>
 #include <stdlib.h>
 #include <time.h>
 #include<string>
 #include<map>

 using namespace std;
 #define N 402222
 typedef long long ll;

 pair<int,int> pt;
 #define mk make_pair
 map<pair<int,int>,int>mp;
 int f[N];

 int find(int x)
 {
     if (f[x]!=x) f[x]=find(f[x]);
     return f[x];
 }

 int main()
 {
     int n;
     scanf("%d",&n);
     int t=;
     for (int i=;i<=n*;i++) f[i]=i;

     int ans=;
     for (int i=;i<=n;i++)
     {
         int x,y,xx,yy;
         scanf("%d%d",&x,&y);
         scanf("%d%d",&xx,&yy);
         if (!mp[mk(x,y)]) mp[mk(x,y)]=++t;
         if (!mp[mk(xx,yy)]) mp[mk(xx,yy)]=++t;
         x=mp[mk(x,y)];
         y=mp[mk(xx,yy)];
         x=find(x);
         y=find(y);
         if (x==y)
         {
             ans=i;
             break;
         }
         else f[x]=y;
     }
     printf("%d\n",ans);
     return ;
 }