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[1<<21];
char ss[50];

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

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

   int tot=1<<len;

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

   int pos;

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

   int num=floor(log(pos)/log(2));
  
   printf("%d\n",num);
   int tmp=num;

   while (pos>1)
   {
     if (pos&1) ss[tmp--]='b';
     else ss[tmp--]='a';
     pos/=2;
   }
 
  for (int i=1;i<=num;i++)
  printf("%c",ss[i]);
  
  printf("\n");  
   return 0;
}


       
  
   

 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[333];
int vis[333];

int col[333];

int ans[333];

int tmp=0;
int flag=0;
void  dfs(int x)
{
    vis[x]=1;
    for (int i=0;i<mp[x].size();i++)
    {
        int v=mp[x][i];
        if (!vis[v])
        {
            col[v]=3-col[x];
            dfs(v);
        }
        else
        {
            if (col[v]==col[x])
            {
                flag=1;
                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=1;i<=n;i++)
    if (!vis[i])
    {
        col[i]=1;
        dfs(i);
        if (flag)
        {
          puts("no");
          return 0;
        }
    }

    puts("yes");

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

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

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

    return 0;
}

 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<<2];
int tot;

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

void init()
{
    tot=0;
    memset(head,-1,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!=-1;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][0].val+c;
        p.idx=v;

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

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

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

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

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

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

        dfs_father(v,u);
     }
 }


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

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


       
  
   

 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]=1;
   for (int i=0;i<mp[u].size();i++)
    {
        int v=mp[u][i];
        if (!vis[v])
        {
            dfs(v);
            if (dp[v]>0) dp[u]+=dp[v];
        
        }
    }

}


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

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

    dfs(1);

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

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=0;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=0;
int ans=1234456;

void cal(int u,int pre)
{
   int tmp=sum[u];
        dp[u]=0;
   for (int i=0;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[1]-sum[u]);
   if (dp[u]==ans)
   {
       ++t;
       a[t]=u;
   }
   else if (dp[u]<ans)
   {
       t=1;
       ans=dp[u];
       a[t]=u;
   }
}

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

 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=0;
    for (int i=1;i<=n*2;i++) f[i]=i;

    int ans=0;
    for (int i=1;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 0;
}