2018.8.6 模拟赛提高组B

T1

Description

给定一个n个点m条边的有向图，有k个标记点，要求从规定的起点按任意顺序经过所有标记点到达规定的终点，问最短的距离是多少。

Input

第一行5个整数n、m、k、s、t，表示点个数、边条数、标记点个数、起点编号、终点编号。

接下来m行每行3个整数x、y、z，表示有一条从x到y的长为z的有向边。

接下来k行每行一个整数表示标记点编号。

Output

输出一个整数，表示最短距离，若没有方案可行输出-1。

Sample Input

3 3 2 1 1

1 2 1

2 3 1

3 1 1

Sample Output

【样例解释】

路径为1->2->3->1。

Data Constraint

20%的数据n<=10。

50%的数据n<=1000。

另有20%的数据k=0。

100%的数据n<=50000，m<=100000，0<=k<=10，1<=z<=5000。

解题思路

考场上一时抽风写了个最短路套状压初值还没附好，50分。。正解应该是将必须经过的点两两之间的最短路求出来之后dfs

代码

#include<iostream>

#include<cstdio>

#include<cstring>

#include<queue>

#define int long long

using namespace std;

const int MAXN = 50005;

const int inf = 0x3f3f3f3f3f3f3f3f;

int n,m,k,S,T,go[MAXN],ans=0x3f3f3f3f3f3f3f3f;

int head[MAXN],cnt,tot;

int to[MAXN<<1],nxt[MAXN<<1],val[MAXN<<1];

int dis[15][MAXN],id[MAXN],dp[(1<<11)+5][15];

bool vis[MAXN],must[MAXN],use[MAXN];

queue<int> Q;

inline int rd(){

    int x=0,f=1;char ch=getchar();

    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}

    while(isdigit(ch))  {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}

    return x*f;

}

inline void add(int bg,int ed,int w){

    to[++cnt]=ed,nxt[cnt]=head[bg],head[bg]=cnt,val[cnt]=w;

}

inline void spfa(int x){

    memset(vis,false,sizeof(vis));

    dis[++tot][x]=0;vis[x]=1;Q.push(x);

    while(!Q.empty()){

        int x=Q.front();Q.pop();

        for(register int i=head[x];i;i=nxt[i]){

            int u=to[i];

            if(dis[tot][x]+val[i]<dis[tot][u]) {

                dis[tot][u]=dis[tot][x]+val[i];

                if(!vis[u]) {

                    vis[u]=1;

                    Q.push(u);

                }

            }

        }

        vis[x]=0;

    }

}

inline void dfs(int x,int now,int sum){

    if(sum>ans) return;

    if(now==k) {ans=min(ans,sum+dis[id[x]][T]);return;}

    for(register int i=1;i<=k;i++){

        if(use[i]) continue;

        use[i]=1;

        dfs(go[i],now+1,sum+dis[id[x]][go[i]]);

        use[i]=0;

    }

}

signed main(){

    memset(dp,0x3f,sizeof(dp));

    memset(dis,0x3f,sizeof(dis));

    n=rd();m=rd();k=rd();S=rd();T=rd();

    for(register int i=1;i<=m;i++){

        int x=rd(),y=rd(),z=rd();

        add(x,y,z);

    }

    for(register int i=1;i<=k;i++){

        int x=rd();must[x]=1;id[x]=i;go[i]=x;

        spfa(x);

    }

    if(!must[S]) spfa(S),id[S]=k+1;

    for(register int i=1;i<=k;i++){

        memset(use,false,sizeof(use));

        if(dis[id[S]][go[i]]==inf) continue;

        use[i]=1;

        if(must[S] && go[i]!=S)

            dfs(go[i],2,dis[id[S]][go[i]]);

        else if(!must[S])

            dfs(go[i],1,dis[id[S]][go[i]]);

    }

    if(k==0) ans=dis[id[S]][T];

    if(ans==inf) ans=-1;

    cout<<ans<<endl;

    return 0;

}

Description

万老师听说某大国很流行穿越，于是他就想写一个关于穿越的剧本。

闲话休提。话说老师穿越到了某一个剑与魔法的大陆。因为如此这般，所以老师从维娜艾那里得到了预言。老师一共被告知了若干件按顺序结算的事件。这些事件分为两类：战役事件（CASE）、穿越回去事件（END）。战役事件可以选择是否参加，参加了之后会获得一定的金钱。每个END事件发生需要至少参加一定数量的战役事件。特别的是，END事件如果满足要求就会强制发生。老师希望在大陆玩个够，所以他要求只有最后一个END事件会发生。老师希望获得最多的金钱，所以求助于你。

Input

第一行一个数N，表示输入文件有多少行。

接下来每一行用空格隔开一个字符和一个整数。字符为“c”表示战役事件，接下来的整数表示这次涨RP顺带有多少钱；字符为“e”表示穿越回去事件，接下来的整数代表至少要涨多少RP。最后一个事件保证是END事件。

Output

第一行一个整数，最多金钱数目。

若不可能则输出-1。

Sample Input

c 10

c 12

e 2

c 1

e 2

Sample Output

Data Constraint

30%的数据满足 N<=20

60%的数据满足 N<=1,000

100%的数据满足 N<=200,000

每次涨RP事件赏金不超过10,000

穿越事件的要求不超过200,000

解题思路

最后的战役事件竟然能超了最后的end！！！我太菜了还以为能相等。。。写了两个小时的线段树+对拍结果0分。。又是一道由100 变成 0的好题。正解是优先队列+贪心。我用的线段树直接先排序，然后每次挑最大的相当于区间修改，从这个战役之后的第一个一直到倒数第二个这段区间-1。

代码

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace std;

const int MAXN = 200005;

const int inf = 0x3f3f3f3f;

int n,cnt1,cnt2,ans,mn[MAXN<<1];

int sum[MAXN<<1],lazy[MAXN<<1];

struct Data{

    int id,a;

}data[3][MAXN];

inline int rd(){

    int x=0,f=1;char ch=getchar();

    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}

    while(isdigit(ch))  {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}

    return x*f;

}

inline bool cmp(Data A,Data B){

    return A.a>B.a;

}

inline void pushdown(int x,int ln,int rn){

    lazy[x<<1]+=lazy[x];

    lazy[x<<1|1]+=lazy[x];

    sum[x<<1]+=ln*lazy[x];

    sum[x<<1|1]+=rn*lazy[x];

    mn[x<<1]+=lazy[x];

    mn[x<<1|1]+=lazy[x];

    lazy[x]=0;

}

inline void build(int x,int l,int r){

    if(l==r){

        sum[x]=data[2][l].a;

        mn[x]=data[2][l].a;

        lazy[x]=0;

        return ;

    }

    int mid=l+r>>1;

    build(x<<1,l,mid);

    build(x<<1|1,mid+1,r);

    sum[x]=sum[x<<1]+sum[x<<1|1];

    mn[x]=min(mn[x<<1],mn[x<<1|1]);

}

inline void update(int x,int l,int r,int L,int R,int k){

    if(L<=l && r<=R){

        sum[x]+=k;mn[x]+=k;lazy[x]+=k;

        return ;

    }

    int mid=l+r>>1;

    if(lazy[x]) pushdown(x,mid-l+1,r-mid);

    if(mid>=L) update(x<<1,l,mid,L,R,k);

    if(mid<R)  update(x<<1|1,mid+1,r,L,R,k);

    sum[x]=sum[x<<1]+sum[x<<1|1];

    mn[x]=min(mn[x<<1],mn[x<<1|1]);

}

inline int query(int x,int l,int r,int L,int R){

    if(L<=l && r<=R) return mn[x];

    int ret=0x3f3f3f3f;

    int mid=l+r>>1;

    if(lazy[x]) pushdown(x,mid-l+1,r-mid);

    if(mid>=L) ret=min(ret,query(x<<1,l,mid,L,R));

    if(mid<R)  ret=min(ret,query(x<<1|1,mid+1,r,L,R));

    return ret;

}

int main(){

    n=rd();

    for(register int i=1;i<=n;i++){

        char c;cin>>c;int x=rd();

        if(c=='c') data[1][++cnt1].a=x,data[1][cnt1].id=i;

        else  data[2][++cnt2].a=x,data[2][cnt2].id=i;

    }

    build(1,1,cnt2);

    sort(data[1]+1,data[1]+1+cnt1,cmp);

    for(register int i=1;i<=cnt1;i++){

        int ID=data[1][i].id;int x=data[1][i].a;

        int l=1,r=cnt2;int now;

        while(l<=r){

            int mid=l+r>>1;

            if(data[2][mid].id<ID) l=mid+1;

            else {

                now=mid;

                r=mid-1;

            }

        }

        int res;

        if(now>cnt2-1) res=inf;

        else res=query(1,1,cnt2,now,cnt2-1);

        if(res>1 || now==cnt2){

            ans+=x;

            if(now!=cnt2)

                update(1,1,cnt2,now,cnt2-1,-1);

        }

    }

    cout<<ans<<endl;

    return 0;

}

T3

Time Limits: 1000 ms Memory Limits: 262144 KB Detailed Limits

Goto ProblemSet

Description

平面上有n个点，求出用这些点可以构成的三角形数。

Input

第一行一个整数n。

接下来n行，每行两个整数，表示点的坐标。

Output

输出仅一个整数，表示所求答案。

Sample Input

0 0

1 1

1 -1

-1 -1

-1 1

Sample Output

Data Constraint

对于50%的数据，n<=300。

对于100%的数据，n<=3000，坐标的绝对值不超过10^4，保证没有重合的点。

解题思路

这道题跟以前做过的数三角形好像啊，结果还是打的暴力。。用容斥的思想，每次枚举一个点，然后枚举其余点算斜率，之后排个序用组合数学。

代码

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<cstdlib>

#include<algorithm>

#define int long long

using namespace std;

const int MAXN = 3005;

const double inf = 1e10+1;

const double eps = 1e-12;

int n,x[MAXN],y[MAXN],sum,cnt;

double slp[MAXN];

inline int rd(){

    int x=0,f=1;char ch=getchar();

    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}

    while(isdigit(ch))  {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}

    return x*f;

}

signed main(){

    freopen("triangle.in","r",stdin);

    freopen("triangle.out","w",stdout);

    n=rd();sum=n*(n-1)*(n-2)/6;

    for(register int i=1;i<=n;i++)

        x[i]=rd(),y[i]=rd();

    for(register int i=1;i<=n;i++){

        memset(slp,0,sizeof(slp));cnt=0;

        for(register int j=i+1;j<=n;j++){

            if(y[i]==y[j]) slp[++cnt]=inf;

            else if(x[i]==x[j]) slp[++cnt]=-inf;

            else slp[++cnt]=(double)(x[i]-x[j])/(y[i]-y[j]);

        }

        sort(slp+1,slp+1+cnt);

        int now=1;slp[0]=-inf-5;

        for(register int j=1;j<=cnt;j++){

            if(fabs(slp[j]-slp[j-1])>eps){

                sum-=now*(now-1)/2;

                now=1;

            }

            else now++;

        }

        sum-=now*(now-1)/2;

    }

    printf("%lld",sum);

    return 0;

}