Live Archive 训练题 2019/3/9

7454 Parentheses

A bracket is a punctuation mark, which is used in matched pairs, usually used within articles or programs. Brackets include round brackets, square brackets, curly brackets, angle brackets, and various other pairs of symbols. Let’s focus on the round brackets, also called parentheses. A sequence of parentheses is said to be well-formed if the parentheses are properly nested. For example, A = a1a2 . . . a18 = “(()())()()()(())()” is well-formed, but B = b1b2 . . . b18 = “(()())))(((((())((” is not. (See Figure 1.) More formally, a sequence of parentheses P = p1p2 . . . pn is well-formed

if (1) when scanning it from p1 to pn, the number of right parentheses does not exceed the number of left parentheses at any state, and

(2) the numbers of left and right parentheses are equal.

Figure 1. Two sequences of parentheses.AutoText is a company, which is developing a text editor for programmers.  The new editor willprovide many powerful functions to automatically correct typing errors. On a keyboard, the left andright parentheses are adjacent. Thus, it is often that “)” is mistyped as “(” or vice versa. And therefore,one of the functions AutoText wants to provide is to automatically convert a sequence of parenthesesP(that may not be well-formed) into a wellformed sequenceP′. In the conversion, the only allowedoperation is to reverse a parenthesis (i.e., either to replace a “(” with a “)” or to replace a “)” witha “(”). For example, in Figure 1, we can convertBinto the well-formed sequenceAby performing 4reverse operations onb7,b10,b12,b18. Of course, there may be several ways to convert a sequence intoa well-formed sequence. A conversion is optimal if it uses the minimum number of reverse operations.Please write a program to compute the minimum number of reverse operations that make a givensequence of parenthesesP=p1p2:::pnwell-formed.InputThe first line contains an integerT10indicating the number of test cases. The first line of each testcase contains an even integern,2n100, indicating the length ofP. Next, the second line givesthe sequenceP.

Output

For each test case, output the minimum number of reverse operations that makePwell-formed.

Sample Input

3

18

(()())))(((((())((

2

()

8

(()))()(

Sample Output

4

0

2

题目意思：对于给出的一系列括号，设计一个AutoText，使得能够自动完成括号匹配，问最少需要转变多少个括号，左括号和右括号可以相互转变。

解题思路：之前经常做这种括号匹配的题目，使用栈先将能够匹配的处理掉，之后栈内不能匹配的两个处理，使其能够匹配即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
stack<char>s;
int main()
{
    int t,n,ans;
    int x,y;
    char c;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        getchar();
        ans=;
        while(!s.empty())///清空栈
        {
            s.pop();
        }
        while(n--)
        {
            scanf("%c",&c);
            if(c=='(')
            {
                s.push(c);
            }
            else if(c==')')
            {
                if(!s.empty()&&s.top()=='(')///已经匹配出栈
                {
                    s.pop();
                }
                else
                {
                    s.push(c);
                }
            }
        }
        x=;
        y=;
        ans=;
        while(!s.empty())
        {
            if(s.top()=='(')
            {
                x++;
            }
            else if(s.top()==')')
            {
                y++;
            }
            if(x==&&y==)///出现')('的情况
            {
                x--;
                y--;
                ans=ans+;///两个同时翻转
            }
            else if(x==)///出现'(('的情况
            {
                x=x-;
                ans++;///翻转一个
            }
            else if(y==)///出现'))'的情况
            {
                y=y-;
                ans++;///翻转一个
            }
            s.pop();
        }
        printf("%d\n",ans);
    }
    return ;
}

7457Discrete Logarithm Problem

题目意思：求一个x使得 a^x%p = b 。

解题思路：开始一看这种表达式，第一反应是快速幂算法，但后来发现数据的规模并不是很大，所以可以直接暴力枚举，同时发现而取模的结果一定在p次以内出现循环，所以直接从0~p枚举x即可。

#include<cstdio>
#include<cstring>
#define ll long long int
#define maxs 102400
using namespace std;
/*ll fast_pow(ll a,ll x,ll p)
{
    ll ans=1;
    a=a%p;
    while(x!=0)
    {
        if(x&1)
        {
            ans=(ans*a)%p;
        }
        x>>=1;
        a=(a*a)%p;
    }
    return ans%p;
}*/
//快速幂
int main()
{
    ll a,b,p,ans,i;
    int flag;
    scanf("%lld",&p);
    while(scanf("%lld",&a)!=EOF)
    {
        if(a==)
        {
            break;
        }
        scanf("%lld",&b);
        ans=a;
        flag=;
        for(i=;i<p;i++)
        {
            ans=(ans*a)%p;
            if(ans==b)
            {
                flag=;
                break;
            }
        }
        if(flag)
        {
            printf("%d\n",i);
        }
        else
        {
            printf("0\n");
        }
    }
    return ;
}

7464Robots

Write a program to collect data from robots. We are given two sets of robotsX=fX1;:::;Xmg,Y=fY1;:::;Yng, and a baseB. Each robot has a data and we would like to compute the sum of datafrom all robots and deliver it to the base. In order to do so a robot can send its data to another robotor the base with the following constraints.

•A robot can only send its data to one destination (a robot or the base) at a time.

•A robot (or the base) can receive data from one robot at a time.

•The base can not send data to anyone.

•A robot inXcan complete sending its data in x seconds.A robot in Y can complete sending its data in y seconds.

The robots and the base can perform addition, so we can collect the final sum at the base. Thatis, we assume that after receiving a data, a robot or the base can perform an addition with zero time.Now let us illustrate this concept by an example. Let us consider a system with one robotX1inXand two robotsY1andY2inY. We also assume thatxis 1 andyis 10. At the beginningY1can sendits data toY2andX1can send its data to the base. After 1 second the base will know the data ofX1.However, only after 10 secondsY2will have the data ofY1, add its own data, and send the sum to thebase. After 20 seconds the base receives the sum of data fromY1andY2, adds the data fromX1, andhas the final sum. The entire summation will take 20 seconds.Now let us try a different schedule. At beginningY1sends data to the base, andY2sends data toX1, and both can complete after 10 seconds. Finally X1 starts sending the sum of data from Y2 anditself to the base after 10 seconds, and the entire summation can finish in 11 seconds.Now givenm,n(the numbers of robots in X and Y),x, andy, please determine the minimumnumber of seconds to finish the summation.Constraints•1x<y1000.•0m<1200.•0n<500.

Input

The input consists of multiple test cases. First line contains a single integertindicating the number oftest cases to follow. Each of the nexttlines contains four integers —x,y,m,n.

Output

For each test case, output on a single line the minimum number of seconds to sum up all numbers fromall robots.

Sample Input

11  10  1  2
Sample Output

11

题目意思：有x,y两种类型的机器人各n个和m个，还有一个基地B,x型的机器人将其货物运到基地或其他机器人上需要x秒，y型的机器人将其货物运到基地或其他机器人上需要y秒，同一时刻每个机器人只能发送给一个对象，也只能接受一个对象的货物，基地在同一时刻也只能接受一个机器人的货物，问你如何搭配才能花费最短的时间将所有的货物运送到基地。

解题思路：我刚开始按照那个样例一直想模拟整个运送过程，但发现还是太麻烦，因为里面有很多种情况的判断，那么我们可以从整体的角度出发，需要最少的时间肯定不能是一个个机器人排队去送货物到基地，必然是将一些耗时大的机器人身上的货物送到耗时少的身上，通过哪些耗时少的来运送。这其实就是第一步，将耗时多的机器人身上的货物尽可能的向耗时少的机器人身上送，这个时间段中可以选择一个耗时多的机器人送货到基地，之后耗时多的机器人不管有没有剩余，和耗时少的机器人只要在条件限定内组合时间就像是左手倒右手，时间是一定的，也就是说我们只能省出一个耗时长的机器人的时间。