TC SRM630 div1

最新推荐文章于 2021-01-03 10:29:58 发布

原创最新推荐文章于 2021-01-03 10:29:58 发布 · 868 阅读

0 ·

CC 4.0 BY-SA版权

topcoder 专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了算法与数据结构在计算机科学领域的核心作用，从排序算法、动态规划、哈希算法等多个角度阐述了它们的重要性。同时，文章还分析了数据结构在实际应用中的优势与挑战，提供了在复杂问题解决中的实用策略。

250：给一颗边上带权的树（n<=50），选取若干个点组成一个集合，要求集合中任意两点间的距离相等，求最多能选多少个点。

大致思路就是枚举一个点作为根节点，这个点伸出的每条边指向一棵子树，每颗子树中选择一个到根节点距离相同的点组成的集合即是要求的集合，所以对每课dfs记录一下每个距离是否出现过，这样枚举每个距离，看它在几个子树中出现个，记一个最大值即可。这题要注意的一个是特判N=1直接返回1，N>1的话，答案最小是2，好多fst的就是挂在这里了...

/*=============================================================================
#  Author:Erich
#  FileName:
=============================================================================*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#define lson id<<1,l,m
#define rson id<<1|1,m+1,r

using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=1ll<<60;
const double PI=acos(-1.0);
int n,m;
const int maxn=105;
struct node
{
    int u,v,w,next;
}edge[1050];
int en;
int g[maxn];
void addedge(int x,int y,int z)
{
    edge[en].u=x; edge[en].v=y;
    edge[en].w=z;
    edge[en].next=g[x];
    g[x]=en++;
}
int num[105*1050];
bool ok[105*1050];
int vis[maxn];
void dfs(int u,int fa,int id,int len)
{
    int v;
    vis[u]=id;
    if (!ok[len])
    {
        ok[len]=true;
        num[len]++;
    }
    for (int j=g[u]; j!=-1; j=edge[j].next)
    {
        v=edge[j].v;
        if (v!=fa && !vis[v])
        {
            dfs(v,u,id,len+edge[j].w);
        }
    }
}
class Egalitarianism3
{
    public:
    int maxCities(int n, vector <int> a, vector <int> b, vector <int> len)
    {
        if (n==1) return 1;
        if (n==2) return 2;
         memset(g,-1,sizeof g);
         en=0;
        int m=a.size();
        int x,y,z;
        for (int i=0; i<m; i++)
        {
            x=a[i]; y=b[i]; z=len[i];
            addedge(x,y,z);
            addedge(y,x,z);
        }
        int ans=1;

        for (int root=1; root<=n; root++)
        {
            memset(vis,0,sizeof vis);
            memset(num,0,sizeof num);
            vis[root]=999;
            int cnt=0;
            for (int j=g[root]; j!=-1; j=edge[j].next)
            {
                memset(ok,false,sizeof ok);
                dfs(edge[j].v,root,++cnt,edge[j].w);
            }
            for (int i=0; i<105*1050; i++) ans=max(num[i],ans);
        }
        return max(2,ans);


    }
}ss;

500：给一个后缀数组，问最少需要几种字符可以组成一个后缀数组与给定的数组相同的字符串。例如{0,1,2,3}的一种情况是aaab，需要a,b两种字符，答案是2.

要做这题首先要会后缀数组，至少得了解后缀数组里的几个基本概念（如sa,rank,height等...），根据给的后缀数组可以求出其rank数组，那么枚举sa[],考虑rank[sa[i]+1],rank[sa[i+1]+1]的意义，首先有suff(sa[i])< suff(sa[i+1])，那么原串第sa[i]位和第sa[i+1]位要么相等，要么前者字典序小于后者，而如果两者相等的话，因为sa[i]在sa[i+1]前面，那么sa[i]后一位的rank就一定要小于sa[i+1]后一位的rank，所以比较rank[sa[i]+1],rank[sa[i+1]+1]，若是小于的话，则说明sa[i]位和sa[i+1]用相同的字符不会产生冲突也就是说可以少用一种字符，那么令答案初值为n，没出现一组rank[sa[i]+1]<rank[sa[i+1]+1]就让其减一，扫一遍sa就可以得到答案。

/*=============================================================================
#  Author:Erich
#  FileName:
=============================================================================*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#define lson id<<1,l,m
#define rson id<<1|1,m+1,r

using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=1ll<<60;
const double PI=acos(-1.0);
int n,m;
int rk[120];
class SuffixArrayDiv1
{
    public:
    int minimalCharacters(vector <int> sa)
    {
        int n=sa.size();
        for (int i=0; i<n; i++) rk[sa[i]]=i;
        rk[n]=-1;
        int ans=n;
        for (int i=0; i<n-1; i++)
        if (rk[sa[i]+1]<rk[sa[i+1]+1]) ans--;
        return ans;

    }
}ff;