哈尔滨理工大学第七届程序设计竞赛初赛（高年级组）

https://www.nowcoder.com/acm/contest/27#question

   A-凌波微步

  LIS恐成最大输家，无力吐槽 = =

B-C水题

D-经商

小d是一个搞房地产的土豪。每个人经商都有每个人经商的手段，当然人际关系是需要放在首位的。

小d每一个月都需要列出来一个人际关系表，表示他们搞房地产的人的一个人际关系网，但是他的精力有限，对应他只能和能够接触到的人交际。比如1认识2,2认识3，那么1就可以接触3进行交际，当然1和2也可以交际。

小d还很精明，他知道他和谁交际的深获得的利益大，接下来他根据自己的想法又列出来一个利益表，表示他和这些人交际需要耗用多少精力，能够获得的利益值为多少。

小d想知道，他在精力范围内，能够获得的利益值到底是多少。

设定小d自己的编号为1.并且对应一个人的交际次数限定为1.

输入描述:

本题包含多组输入，第一行输入一个数t，表示测试数据的组数
每组数据的第一行输入三个数，N,M，C，表示这个人际关系网一共有多少个人，关系网的关系数，以及小d的精力值
接下来N-1行，每行两个数ai，bi。这里第i行表示和编号为i+1的人认识需要花费ai的精力，能够获得的利益值为bi。
再接下来M行，每行两个数x，y，表示编号为x的人能够和编号为y的人接触
t<=50
2<=N<=10000
1<=M<=10*N
1<=ai，bi<=10
1<=C<=500
1<=x,y<=N

输出描述:

输出包含一行，表示小d能够获得的最大利益值

示例1

输入

1
5 3 7
5 10
3 2
4 3
1 100
1 2
2 3
1 4

输出

10
并查集统计出1所有能接触到的人+背包求解最优值

#include<bits/stdc++.h>
using namespace std;
int f[10005],dp[550];
int getf(int v){return f[v]==v?v:f[v]=getf(f[v]);}
struct node
{
    int a,b;
}P[10005],Q[10005];
int main()
{
    int T,N,M,C,i,j,k,x,y;
    scanf("%d",&T);
    while(T--){int sq=0;
    memset(dp,0,sizeof(dp));
        scanf("%d%d%d",&N,&M,&C);
        for(i=1;i<=N;++i) f[i]=i;
        for(i=2;i<=N;++i)
        {
            scanf("%d%d",&P[i].a,&P[i].b);
        }
        for(i=1;i<=M;++i)
        {
            scanf("%d%d",&x,&y);
            int fx=getf(x),fy=getf(y);
            if(fx!=fy){
                f[fx]=fy;
            }
        }
        for( i=1;i<=N;++i) f[i]=getf(i);
        int root=f[1];
        for(i=2;i<=N;++i)
        {
            if(f[i]==root){
                Q[++sq]=P[i];
            }
        }
        for(i=1;i<=sq;++i)
        {
            for(j=C;j>=Q[i].a;--j)
                dp[j]=max(dp[j],dp[j-Q[i].a]+Q[i].b);
        }
        cout<<dp[C]<<endl;
    }
    return 0;
}

F-苦逼的单身狗
尺取法，枚举左边界，指定情况出现时再指定情况未消失时不断右移左边界并统计数量。

#include<bits/stdc++.h>
using namespace std;
char s[100005];
int vis[5];
int zh[30];
#define inf 0x3f3f3f3f
int main()
{
    int t,n,m,i,j,k;
    zh['L']=1;
    zh['O']=2;
    zh['V']=3;
    zh['E']=4;
    cin>>t;
    while(t--){
            cin>>s;
            memset(vis,0,sizeof(vis));
    int len=strlen(s);
    long long ans=0;
    int cur=0;
    for(i=0;i<len;++i)
    {
       k=zh[s[i]];
       if(k){
        vis[k]++;
       }
       while(cur<=i&&vis[4]&&vis[1]&&vis[2]&&vis[3]){
        ans+=(long long )len-i;//cout<<len-i<<endl;
        if(zh[s[cur]]) vis[zh[s[cur]]]--;
        cur++;
       }
    }
    printf("%lld
",ans);
    }
    return 0;
}

H-布置会场

矩阵幂裸题。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;
#define LL long long
LL M=1000000007;
 
struct Matrix {
    long long a[2][2];
    Matrix() {
        memset(a, 0, sizeof(a));
    }
    Matrix operator * (const Matrix y) {
        Matrix ans;
        for(int i = 0; i <= 1; i++)
            for(int j = 0; j <= 1; j++)
                for(int k = 0; k <= 1; k++)
                    ans.a[i][j] += a[i][k]*y.a[k][j];
        for(int i = 0; i <= 1; i++)
            for(int j = 0; j <= 1; j++)
                ans.a[i][j] %= M;
        return ans;
    }
    void operator = (const Matrix b) {
        for(int i = 0; i <= 1; i++)
            for(int j = 0; j <= 1; j++)
                a[i][j] = b.a[i][j];
    }
};
 
int solve(long long x) {
    Matrix ans, trs;
    ans.a[0][0] = ans.a[1][1] = 1;
    trs.a[0][0] = trs.a[1][0] = trs.a[0][1] = 1;
    while(x) {
        if(x&1)
            ans = ans*trs;
        trs = trs*trs;
        x >>= 1;
    }
    return ans.a[0][0];
}
 
int main() {
    long long n;
    int t;
    cin>>t;
    while(t--){
    scanf("%lld", &n);
    cout << solve(n) << endl;
    }
    return 0;
}

I-旅行
最短路+思维。
题目很显然就是求最大化的{任意有两条最短路连接的三个点中的这两条最短路径长度和},其中三个点互不相等。
 首先我们要求出任意两点间的最短路这是肯定的，有N^3的floyd或是N*N*log(N)的dij，前者肯定炸了。对于后面的找这三个点的过程一直想的是N*N*N，这样的话无论最短路算法在再优化也会T，比赛时迫于时间
直接暴力了个floyd直接炸了。
 其实找点用不到这么麻烦，题目求得时最大化的，三个点显然只有两条最短路，我们枚举1-n作为中转点，没次找到中转点对于其他点最大的两条最短路更新答案就好了。这样找的复杂度就降到了N^2不会T了。
好题。

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
struct Edge
{
    int to,w,next;
}e[2010];
int first[1010],cnt;
struct node
{
    int u,w;
    bool operator<(const node& t)const{
    return w>t.w;
    }
};
void add(int u,int v,int w)
{
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=first[u];
    first[u]=cnt++;
}
int d[1005][1005];
bool vis[1005];
void dij(int u,int n)
{
    priority_queue<node>Q;
    node t1,t2;
    memset(vis,0,sizeof(vis));
    d[u][u]=0;
    Q.push(node{u,0});
    while(!Q.empty()){
        t1=Q.top();
        Q.pop();
        if(vis[t1.u]) continue;
        vis[t1.u]=1;
        for(int i=first[t1.u];i+1;i=e[i].next){
            if(d[u][e[i].to]>d[u][t1.u]+e[i].w){
                d[u][e[i].to]=d[u][t1.u]+e[i].w;
                Q.push(node{e[i].to,d[u][e[i].to]});
            }
        }
    }
}
int main()
{
    int t,n,m,i,j,k,u,v,w;
    cin>>t;
    while(t--){
        cin>>n>>m;
        memset(first,-1,sizeof(first));
        memset(d,inf,sizeof(d));
        cnt=0;
        for(i=1;i<=m;++i)
        {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
        }
        for(i=1;i<=n;++i) dij(i,n);
        int ans=-1;
        for(i=1;i<=n;++i)
        {
            int t1=-1,t2=-1,maxn=0;
            for(j=1;j<=n;++j)
            {
                if(d[i][j]!=inf&&d[i][j]>maxn){
                    maxn=d[i][j];
                    t1=j;
                }
            }
            maxn=0;
            for(j=1;j<=n;++j)
            {
                if(j!=t1&&d[i][j]!=inf&&d[i][j]>maxn){
                    maxn=d[i][j];
                    t2=j;
                }
            }
            if(t1!=-1&&t2!=-1){
                ans=max(ans,d[i][t1]+d[i][t2]);
            }
        }
        printf("%d
",ans);
    }
    return 0;
}