BUPT2014新生暑假个人排位赛09

最新推荐文章于 2018-04-04 00:49:34 发布
最新推荐文章于 2018-04-04 00:49:34 发布
阅读量619 收藏 1
点赞数
分类专栏： 数学 & 博弈论 & FFT & 位运算 数据结构 & hash 图论 & 网络流 动态规划 & 贪心 文章标签： bupt BOJ ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/38341211
版权

475. 小妹妹快递公司的新址

BOJ 470 diffsum
一开始思路有问题，但是实在是没有成功构建出能够hack自己的数据
思路有两个
第一个是，峰神神奇的证明出了，答案是由数列从大到小排列后，以 n-1 为首项， 2 为公差的等差数列 为系数的和 
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define eps 1e-9
#define ll long long
 
using namespace std;
 
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
 
//-----------------------------------------------------------------------
 
const int MAXN=100010;
int n,m;
int a[MAXN];
 
int main()
{
    while(read(n))
    {
        ll temp=n-1;
        ll ans=0,fusum=0,zhsum=0;
        ll zhnum=0,funum=0;
        
        for(int i=0;i<n;i++)
            scanf("%lld",&a[i]);
        if(n==1)
        {
            printf("0\n");continue;
        }
        sort(a,a+n);
        for(int i=n-1;i>=0;i--)
        {
            ans+=temp*a[i];temp-=2;
        }
        printf("%lld\n",ans);
    }
    return 0;
}

第二个则是我的想法
将数列按照递增排序，改点的角标乘以改点的值减去改点的前缀和 
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define eps 1e-9
#define ll long long

using namespace std;


template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}

//-----------------------------------------------------------------------

const int MAXN=100010;

ll a[MAXN];
ll sum[MAXN];
int main()
{

    int n, m, t;
    ll ans=0;
    while(read(n))
	{
 		ans=0;
	    for(int i=0;i<n;i++)
	        read(a[i]);
	    sort(a,a+n);
	    sum[0]=a[0];
	    for(int i=1;i<n;i++)
		{
	        sum[i]=sum[i-1]+a[i];
	        ans=ans-sum[i-1]+a[i]*i;
	    }
	    printf("%lld\n",ans);
    }
    return 0;
}

BOJ 474 小妹妹送很多快递

最小生成树
在边权不为0的时候，答案加上（左边集合的元素个数）*（右边集合的元素个数）*（边权）
在边权为1的时候，将边权特判为1，继续上面操作 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define INF 0x3f3f3f3f
#define ll long long
 
using namespace std;
 
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
 
//-----------------------------------------------------------------------
 
const int MAXN=10010;
const int MAXE=100010;
 
struct Edge
{
    int u,v,w;
}e[MAXE];
 
 
int n,m;
int fa[10010],rank[MAXN],sum[MAXN];
int tot;
 
int find_fa(int x)
{
    if(fa[x]==x)
        return x;
    else
        return fa[x]=find_fa(fa[x]);
}
 
void Merge(int x,int y)
{
    if(rank[x]>rank[y])
    {
        fa[y]=x;
        sum[x]+=sum[y];
    }
    else
    {
        fa[x]=y;
        sum[y]+=sum[x];
        if(rank[x]==rank[y])
            rank[y]++;
    }
}
 
bool cmp(Edge a,Edge b)
{
    return a.w<b.w;
}
 
void Kruskal()
{
    sort(e+1,e+m+1,cmp);
    ll ans=0;
    for(int i=1;i<=m;i++)
    {
        int xx=find_fa(e[i].u);
        int yy=find_fa(e[i].v);
        if(xx!=yy)
        {
            tot--;
            if(!e[i].w)
                ans+=2*sum[xx]*sum[yy];
            else
                ans+=2*sum[xx]*sum[yy]*e[i].w;
            Merge(xx,yy);
        }
    }
    printf("%lld\n",ans);
}
 
 
int main()
{
    int T;
    read(T);
    while(T--)
    {
       read(n);read(m);
       memset(rank,0,sizeof(rank));
       tot=n;
       for(int i=1;i<=n;i++)
           fa[i]=i,sum[i]=1;
       for(int i=1;i<=m;i++)
       {
           read(e[i].u);read(e[i].v);read(e[i].w);
       }
        Kruskal();
    }
    return 0;
}

BOJ 477 新来的小妹妹

模板题
维护后缀树
计算后缀树中最长重复子串的位置（即height数组） 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define EPS 1e-10
#define INF 0x3f3f3f3f
#define ll long long
 
using namespace std;
 
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n) {
    if(n < 0) {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n) {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
 
 
//-----------------------------------------------------------------------
 
const int MAXN=200000;
 
void radix(int *str,int *a,int *b,int n,int m)
{
    static int count[200000];
    memset(count,0,sizeof(count));
    for(int i=0;i<n;++i)
        ++count[str[a[i]]];
    for(int i=1;i<=m;++i)
        count[i]+=count[i-1];
    for(int i=n-1;i>=0;--i)
        b[--count[str[a[i]]]]=a[i];
}
 
void suffix_array(int *str,int *sa,int n,int m)
{
    static int rank[200000],a[200000],b[200000];
    for(int i=0;i<n;i++)
        rank[i]=i;
    radix(str,rank,sa,n,m);
    rank[sa[0]]=0;
    for(int i=1;i<n;i++)
        rank[sa[i]]=rank[sa[i-1]]+(str[sa[i]]!=str[sa[i-1]]);
    for(int i=0;1<<i <n;++i)
    {
        for(int j=0;j<n;++j)
        {
            a[j]=rank[j]+1;
            b[j]=j +(1<<i)>=n? 0:rank[j+(1<<i)] +1;
            sa[j]=j;
        }
        radix(b,sa,rank,n,n);
        radix(a,rank,sa,n,n);
        rank[sa[0]]=0;
        for(int j=1;j<n;j++)
        {
            rank[sa[j]]=rank[sa[j-1]]+(a[sa[j-1]]!=a[sa[j]]||b[sa[j-1]]!=b[sa[j]]);
        }
    }
}
 
string duplicate_substr(string str)
{
    string rev;
    static int s[3000],sa[3000],rank[3000],h[3000];
    int n=str.length();
    copy(str.begin(),str.end(),s);
    suffix_array(s,sa,n,256);
    for(int i=0;i<n;++i)
        rank[sa[i]]=i;
    int k=0;
    int ans1=0,pos1=0;
    for(int i=0;i<n;i++)
    {
        k= k==0? 0:k-1;
        while(rank[i]>0&&s[i+k]==s[sa[rank[i]-1]+k])
            ++k;
        h[rank[i]]=k;
        if(h[rank[i]]>ans1)
        {
            ans1=h[rank[i]];
            pos1=i;
        }
    }
    return str.substr(pos1,ans1);
}
 
int main()
{
    int T;
    read(T);
    while(T--)
    {
        string s;
        cin>>s;
        s=duplicate_substr(s);
        printf("%d\n",s.length());
    }
    return 0;
}

BOJ 476 学妹去搬砖

最简单的轮廓线DP之一
模板题 

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define eps 1e-9
#define INF 0x3f3f3f3f
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
 
template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1; char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------
 
const int MAXN=11;
const int MOD=1000000007;
 
int n,m,k;
ll dp[2][1<<MAXN];
int color[MAXN][MAXN];
 
void DP()
{
    ll *crt=dp[0],*next=dp[1];
    crt[0]=1;
    for(int i=n-1;i>=0;i--)
    {
        for(int j=m-1;j>=0;j--)
        {
            for(int used=0;used< 1<<m;used++)
            {
                if((used>>j & 1)||color[i][j])
                    next[used]=crt[used & ~(1<<j)];
                else
                {
                    ll res=0;
                    if(j+1<m && !(used>>(j+1) & 1) && !color[i][j+1])
                    {
                        res+=crt[used | 1<<(j+1)];
                    }
                    if(i+1<n && !color[i+1][j])
                    {
                        res+=crt[used | 1<<j];
                    }
                    next[used]= res % MOD;
                }
            }
            swap(crt,next);
        }
    }
    printf("%lld\n",crt[0]);
}
 
int main()
{
    while(read(n)&&read(m)&&read(k))
    {
        int x,y;
        memset(color,0,sizeof(color));
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=k;i++)
        {
            read(x);read(y);
            color[x][y]=1;
        }
        DP();
    }
    return 0;
}


BOJ 475 小妹妹快递公司的新址

先求出该树的重心，然后以重心为根重新计算子孙的个数
同时，更新dp[ i ][ j ] （表示以 i 为根，有 j 个节点的子树的个数）状态转移为 dp 【father】【num】 + = ( dp【father】【num - k 】* dp【child】【k】) 
计算出来以后就开始一个神奇的DP，DP的思路是birdsrom写的..... 
</pre></div><pre name="code" class="cpp">#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#define eps 1e-9
#define INF 0x3f3f3f3f

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=222;
const int MOD=10007;

struct Edge
{
    int to,next;
} e[MAXN*2];
int n,mi;
int head[MAXN],tot=0;
int son[MAXN],cen,pre[MAXN];
int dp[MAXN][MAXN],sum[MAXN],child[MAXN];
bool vis[MAXN];

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

int dfsson(int x)
{
    int y,mx=0;
    vis[x]=true;
    son[x]=1;
    for(int i=head[x];~i;i=e[i].next)
    {
        y=e[i].to;
        if(vis[y])
            continue;
        int tm=dfsson(y);
        mx=max(tm,mx),son[x]+=tm;
    }
    mx=max(mx,n-son[x]);
    if (mx<mi)
    {
        mi=mx,cen=x;
    }
    return son[x];
}

int dfs(int x)
{
    dp[x][0]=dp[x][1]=1;child[x]=1;//cout<<x<<" "<<pre[x]<<endl;system("pause");
    for(int i=head[x];~i;i=e[i].next)
    {
        int y=e[i].to;
        if(pre[y])
            continue;
        pre[y]=x;
        ;
        child[x]+=dfs(y);
    }
    for(int i=head[x];~i;i=e[i].next)
    {
        int y=e[i].to;
        if(pre[x]==y)
            continue;
        for(int i=child[x];i>=2;i--)
            for(int j=1;j<i&&j<=child[y];j++)
                dp[x][i]=(dp[x][i]+dp[y][j]*dp[x][i-j])%MOD;
    }
    return child[x];
}

int main()
{
    int T;
//    freopen("data.txt","r",stdin);
    read(T);
    while(T--)
    {
        memset(head,-1,sizeof(head));
        memset(dp,0,sizeof(dp));
        memset(pre,0,sizeof(pre));
        memset(vis,false,sizeof(vis));
        tot=0;
        read(n);mi=n;
        int u,v;
        for(int i=0; i<n-1; i++)
        {
            read(u),read(v);
            add(u,v);
        }
        dfsson(1);
        pre[cen]=-1;
        dfs(cen);//cout<<cen<<endl;
        int ret=0,ans=0;
        for(int i=1;i<=n;i++)
            ans=(ans+dp[cen][i])%MOD;
        ret=ans;
        for(int k=head[cen];~k;k=e[k].next)
        {
            for(int i=0;i<=n;i++)
                sum[i]=dp[cen][i];
            int y=e[k].to;
            for(int i=1;i<=n;i++)
                for(int j=1;j<i;j++)
                    sum[i]=((sum[i]-sum[i-j]*dp[y][j])%MOD+MOD)%MOD;
        //下面是birdstorm的思路，我实在是写不下去了
            sum[0]=1;
            for(int i=1;i<n;i++)
                sum[i]=(sum[i-1]+sum[i+1])%MOD;
            for(int i=1;i<=n;i++)
                ret=((ret-dp[y][i]*sum[i-1])%MOD+MOD)%MOD;
        }
        printf("%d\n",(ans-ret+MOD)%MOD);
    }
    return 0;
}


SuPhoebe
关注
专栏目录
BUPT 2014新生暑假个人排位赛05
Mr.Phoebe的专栏
07-23 778
BOJ 442 平方的平均值 注意看题啊，用long long和绝对值是肯定
BUPT2014新生暑假个人排位赛07
Mr.Phoebe的专栏
07-28 813
B469. 暑假作业题
BUPT2014新生暑假个人排位赛08
Mr.Phoebe的专栏
07-30 765
BOJ 448 游戏 计算几何
BUPT 2014新生暑假个人排位赛04
Mr.Phoebe的专栏
07-22 807
BOJ 437 大家一起点外卖
BUPT2014新生暑假个人排位赛06
Mr.Phoebe的专栏
07-25 860
BOJ 447 修路 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include us
BUPT 2014新生暑假个人排位赛03
Mr.Phoebe的专栏
07-18 932
A. 学姐的数码管
BUPT 2014新生暑假个人排位赛02
Mr.Phoebe的专栏
07-17 962
A. 丁神去谷歌
BUPT 2014新生暑假个人排位赛01
Mr.Phoebe的专栏
07-15 839
A.学姐的桌面 B.学姐去学车 C.学姐的学弟 D.BLOCK
BUPT 2014新生暑假个人排位赛11
Mr.Phoebe的专栏
08-06 1514
488. 小妹妹个数
Bupt 13级新生专题训练① String1
08-03
本题“Bupt 13级新生专题训练① String1”涉及到的关键知识点是回文判断，其中包括两种类型的回文：普通回文和镜像回文。 1. **普通回文**：一个字符串如果正读和反读是一样的，那么它就是一个普通回文。例如，...
BUPT NoSQL数据库
03-31
本章节主要探讨了NoSQL数据库中的三种重要类型：图数据库、文档数据库和列族数据库，并结合北京邮电大学（BUPT）的相关课程作业进行深入学习。 首先，让我们详细了解一下图数据库。图数据库以节点、边和属性三元组...
BUPT_transform.zip_BUPT__BUPT_transform_bupt matlab
07-14
本源码结合了rotate和skew，既可以单独执行rorate或者skew，也可以改变此两种方法的顺序来研究不同转换顺序带来的不同结果
BUPT数据库实验大三
06-29
本实验主要针对北京邮电大学（BUPT）计算机学院的大三学生，旨在通过实践加深对数据库理论的理解，提高操作数据库的能力。实验涵盖了从基础到进阶的多个方面，包括实验一至实验六，每个实验都有相应的实验报告和数据...
BUPT软件工程分布式温控系统
11-07
在本项目“BUPT软件工程分布式温控系统”中，我们看到了一个基于Python编程语言实现的系统，结合了PyQT5图形用户界面库和MySQL数据库技术。 1. **Python编程**：Python是一种高级编程语言，以其简洁的语法和强大的...
4和7是一个幸运数字
Mr.Phoebe的专栏
04-04 6884
一个比较有趣的面试题 题意： 仅由4和7组成的十进制数字被称为幸运数字，如，4，7，44，47。 那么仅由幸运数字乘积得到的数字为超级幸运数字，如，28 = 4 * 7。 现在给你两个数字表示上下限，让你求这段区间内有多少个超级幸运数字。总共有1000组查询，上下限最多到1012101210^{12}。 思路： 第一想法是容斥搞一下，但是其实非常难，因为除了爆搜很难去构造出仅由幸运数字...
模拟退火算法分析
Mr.Phoebe的专栏
02-05 3392
一. 爬山算法 ( Hill Climbing )          介绍模拟退火前，先介绍爬山算法。爬山算法是一种简单的贪心搜索算法，该算法每次从当前解的临近解空间中选择一个最优解作为当前解，直到达到一个局部最优解。          爬山算法实现很简单，其主要缺点是会陷入局部最优解，而不一定能搜索到全局最优解。如图1所示：假设C点为当前解，爬山算法搜索到A点这个局部最优解就会停止搜索，因为
HDU 5307 He is Flying【FFT】
Mr.Phoebe的专栏
07-24 2044
题意： 有n段路，每段路长度为sis_i，你从节点i到节点j，可以获得一个开心值j−i+1j-i+1，然后问你，主人公走过了所有总长度为ss的段，问你有多少开心值。 思路： 首先想到的就是类似于组合数学那样，于是就想到了母函数： (∑ix∑si)(∑x−∑si−1)−(∑x∑si)(∑(i−1)x−∑si−1)(\sum ix^{\sum s_i})(\sum x^{-\sum s_{i-1
位运算趣题
Mr.Phoebe的专栏
09-04 1808
一个CMU的同学问了我几道题。/* * divpwr2 - Computer x/(2^n). for 0<= n <=30 * Legel ops: ! ~ & ^ | + << >> * Max ops: 15 */int divpwr(int x, int n) { int tmp = ((x^(x>>31))) + !!(x>>31))>>n; return (tmp
BUPT信安大三上信息系统安全复习要点解析
"这是一份关于北京邮电大学（BUPT）信息安全专业大三上学期信息系统安全课程的期末复习资料，涵盖了信息系统安全的基础概念、安全威胁、保障模型、安全需求、风险管理和等级保护等方面的内容。" 在第一章中，讨论了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值