AtCoder Regular Contest 083

C - Sugar Water

Time limit : 3sec / Memory limit : 256MB

Score : 300 points

Problem Statement

Snuke is making sugar water in a beaker. Initially, the beaker is empty. Snuke can perform the following four types of operations any number of times. He may choose not to perform some types of operations.

Operation 1: Pour 100A grams of water into the beaker.
Operation 2: Pour 100B grams of water into the beaker.
Operation 3: Put C grams of sugar into the beaker.
Operation 4: Put D grams of sugar into the beaker.

In our experimental environment, E grams of sugar can dissolve into 100 grams of water.

Snuke will make sugar water with the highest possible density.

The beaker can contain at most F grams of substances (water and sugar combined), and there must not be any undissolved sugar in the beaker. Find the mass of the sugar water Snuke will make, and the mass of sugar dissolved in it. If there is more than one candidate, any of them will be accepted.

We remind you that the sugar water that contains a grams of water and b grams of sugar is

100b

a+b

percent. Also, in this problem, pure water that does not contain any sugar is regarded as 0 percent density sugar water.

Constraints

1≤A<B≤30
1≤C<D≤30
1≤E≤100
100A≤F≤3 000
A, B, C, D, E and F are all integers.

Inputs

Input is given from Standard Input in the following format:

A B C D E F

Outputs

Print two integers separated by a space. The first integer should be the mass of the desired sugar water, and the second should be the mass of the sugar dissolved in it.

Sample Input 1

Copy

1 2 10 20 15 200

Sample Output 1

Copy

110 10

In this environment, 15 grams of sugar can dissolve into 100 grams of water, and the beaker can contain at most 200 grams of substances.

We can make 110 grams of sugar water by performing Operation 1 once and Operation 3 once. It is not possible to make sugar water with higher density. For example, the following sequences of operations are infeasible:

If we perform Operation 1 once and Operation 4 once, there will be undissolved sugar in the beaker.
If we perform Operation 2 once and Operation 3 three times, the mass of substances in the beaker will exceed 200 grams.

Sample Input 2

Copy

1 2 1 2 100 1000

Sample Output 2

Copy

200 100

There are other acceptable outputs, such as:

400 200

However, the output below is not acceptable:

300 150

This is because, in order to make 300 grams of sugar water containing 150 grams of sugar, we need to pour exactly 150 grams of water into the beaker, which is impossible.

Sample Input 3

Copy

17 19 22 26 55 2802

Sample Output 3

Copy

2634 934

暴力枚举啊

#include<stdio.h>

int main()

{

    int A,B,C,D,E,F,x=,y=;

    scanf("%d%d%d%d%d%d",&A,&B,&C,&D,&E,&F);

    for(int i=; i<=F/(*A); i++)

    {

        int a=i**A;

        if(a>F) break;

        for(int j=; j<=F/(*B); j++)

        {

            int b=j**B;

            if(a+b>F) break;

            for(int k=; k<F/C; k++)

            {

                int c=k*C;

                if(a+b+c>F) break;

                for(int l=; l<F/D; l++)

                {

                    int d=l*D;

                    if((a+b+c+d)>F||(c+d)>(a+b)/*E) break;

                    int tz=(c+d);

                    int tm=(a+b);

                    if(x*(tm+tz)<=tz*(y+x))

                    {

                        x=tz;

                        y=tm;

                    }

                }

            }

        }

    }

    printf("%d %d",x+y,x);

    return ;

}

D - Restoring Road Network

Time limit : 2sec / Memory limit : 256MB

Score : 500 points

Problem Statement

In Takahashi Kingdom, which once existed, there are N cities, and some pairs of cities are connected bidirectionally by roads. The following are known about the road network:

People traveled between cities only through roads. It was possible to reach any city from any other city, via intermediate cities if necessary.
Different roads may have had different lengths, but all the lengths were positive integers.

Snuke the archeologist found a table with N rows and N columns, A, in the ruin of Takahashi Kingdom. He thought that it represented the shortest distances between the cities along the roads in the kingdom.

Determine whether there exists a road network such that for each u and v, the integer Au,v at the u-th row and v-th column of A is equal to the length of the shortest path from City u to City v. If such a network exist, find the shortest possible total length of the roads.

Constraints

1≤N≤300
If i≠j, 1≤Ai,j=Aj,i≤109.
Ai,i=0

Inputs

Input is given from Standard Input in the following format:

N

A1,1 A1,2 … A1,N

A2,1 A2,2 … A2,N

…

AN,1 AN,2 … AN,N

Outputs

If there exists no network that satisfies the condition, print -1. If it exists, print the shortest possible total length of the roads.

Sample Input 1

Copy

Sample Output 1

Copy

The network below satisfies the condition:

City 1 and City 2 is connected by a road of length 1.
City 2 and City 3 is connected by a road of length 2.
City 3 and City 1 is not connected by a road.

Sample Input 2

Copy

Sample Output 2

Copy

-1

As there is a path of length 1 from City 1 to City 2 and City 2 to City 3, there is a path of length 2 from City 1 to City 3. However, according to the table, the shortest distance between City 1 and City 3 must be 3.

Thus, we conclude that there exists no network that satisfies the condition.

Sample Input 3

Copy

5

0 21 18 11 28

21 0 13 10 26

18 13 0 23 13

11 10 23 0 17

28 26 13 17 0

Sample Output 3

Copy

Sample Input 4

Copy

3

0 1000000000 1000000000

1000000000 0 1000000000

1000000000 1000000000 0

Sample Output 4

Copy

3000000000

Floyd最短路啊，然后统计下就好的

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N=;

ll sum;

int a[N][N],p[N][N];

int n;

int main()

{

    cin>>n;

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

        for(int j=; j<=n; j++)

            cin>>a[i][j],sum+=a[i][j];

    for(int k=; k<=n; k++)

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

            for(int j=; j<=n; j++)

                if(a[i][k]+a[k][j]<a[i][j])

                {

                    cout<<-;

                    return ;

                }

    for(int k=; k<=n; k++)

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

            for(int j=; j<=n; j++)

                if(a[i][k]+a[k][j]==a[i][j]&&i!=k&&k!=j&&i!=j)

                    p[i][j]=;

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

            for(int j=; j<=n; j++)

                if(p[i][j])

                    sum-=a[i][j];

    cout<<sum/;

    return ;

}

E - Bichrome Tree

Time limit : 2sec / Memory limit : 256MB

Score : 700 points

Problem Statement

We have a tree with N vertices. Vertex 1 is the root of the tree, and the parent of Vertex i (2≤i≤N) is Vertex Pi.

To each vertex in the tree, Snuke will allocate a color, either black or white, and a non-negative integer weight.

Snuke has a favorite integer sequence, X1,X2,…,XN, so he wants to allocate colors and weights so that the following condition is satisfied for all v.

The total weight of the vertices with the same color as v among the vertices contained in the subtree whose root is v, is Xv.

Here, the subtree whose root is v is the tree consisting of Vertex v and all of its descendants.

Determine whether it is possible to allocate colors and weights in this way.

Constraints

1≤N≤1 000
1≤Pi≤i−1
0≤Xi≤5 000

Inputs

Input is given from Standard Input in the following format:

N

P2 P3 … PN

X1 X2 … XN

Outputs

If it is possible to allocate colors and weights to the vertices so that the condition is satisfied, print POSSIBLE; otherwise, print IMPOSSIBLE.

Sample Input 1

Copy

Sample Output 1

Copy

POSSIBLE

For example, the following allocation satisfies the condition:

Set the color of Vertex 1 to white and its weight to 2.
Set the color of Vertex 2 to black and its weight to 3.
Set the color of Vertex 3 to white and its weight to 2.

There are also other possible allocations.

Sample Input 2

Copy

Sample Output 2

Copy

IMPOSSIBLE

If the same color is allocated to Vertex 2 and Vertex 3, Vertex 2 cannot be allocated a non-negative weight.

If different colors are allocated to Vertex 2 and 3, no matter which color is allocated to Vertex 1, it cannot be allocated a non-negative weight.

Thus, there exists no allocation of colors and weights that satisfies the condition.

Sample Input 3

Copy

8

1 1 1 3 4 5 5

4 1 6 2 2 1 3 3

Sample Output 3

Copy

POSSIBLE

Sample Input 4

Copy

1

0

Sample Output 4

Copy

POSSIBLE

以下是某个聚聚的做法，建图暴力dfs+bitset，这个bitset的操作我不是很明白啊

#include<bits/stdc++.h>

using namespace std;

const int N=,M=;

int i,j,k,n,m,En;

int h[N],fa[N],f[N],X[N];

bitset<M>g;

struct edge

{

    int s,n;

} E[N];

void E_add(int x,int y)

{

    E[++En].s=y;

    E[En].n=h[x];

    h[x]=En;

}

bool dfs(int x)

{

    for(int k=h[x]; k; k=E[k].n)

        if(!dfs(E[k].s))

            return ;

    g.reset();

    g[]=;

    int sum=;

    for(int k=h[x]; k; k=E[k].n)

    {

        g=g<<X[E[k].s]|g<<f[E[k].s];

        sum+=X[E[k].s]+f[E[k].s];

    }

    for(int i=X[x]; i>=; i--)

        if(g[i])

        {

            f[x]=sum-i;

            return ;

        }

    return ;

}

int main()

{

    scanf("%d",&n);

    for(i=; i<=n; i++)

        scanf("%d",&fa[i]),E_add(fa[i],i);

    for(i=; i<=n; i++)

        scanf("%d",&X[i]);

    puts(dfs()?"POSSIBLE":"IMPOSSIBLE");

    return ;

}