2017-10-03-afternoon

P100

zhx

竞赛时间：????年??月??日??:??-??:??

题目名称	a	b	c
名称	a	b	c
输入	a.in	b.in	c.in
输出	a.out	b.out	c.out
每个测试点时限	1s	1s	1s
内存限制	256MB	256MB	256MB
测试点数目	6	100 或 200	10
每个测试点分值	16 或者 17	1 或 0.5	10
是否有部分分	无	无	无
题目类型	传统	传统	传统

注意事项（请务必仔细阅读）：

P100 zhxa

T1 a

【问题描述】

你是能看到第一题的 friends 呢。

——hja

给你一个只有小括号和中括号和大括号的括号序列，问该序列是否合法。

【输入格式】

一行一个括号序列。

【输出格式】

如果合法，输出 OK，否则输出 Wrong。

【样例输入】

[(])

【样例输出】

Wrong

【数据范围与规定】

对于70%的数据，1 ≤N≤ 100。

对于100%的数据，1 ≤N≤ 10000，所有单词由大写字母组成。

栈模拟

#include <cstring> 
#include <cstdio>

const int N(10005);
char s[N],stack[N];
int top;

int Presist()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    scanf("%s",s+1);  int n=strlen(s+1);
    if(n&1) { printf("Wrong"); return 0; }
    for(int i=1; i<=n; ++i)
    {
        if(s[i]=='[') stack[++top]='[';
        else if(s[i]=='(') stack[++top]='(';
        else if(s[i]==']')
             {
                 if(!top||stack[top--]!='[')
                 {
                     printf("Wrong");
                     return 0;
                }
             }
        else if(s[i]==')')
             {
                 if(!top||stack[top--]!='(')
                 {
                     printf("Wrong");
                     return 0;
                }
             }
    }
    printf("OK");
    return 0;
}

int Aptal=Presist();
int main(int argc,char**argv){;}

T2 b

【问题描述】

你是能看到第二题的 friends 呢。

——laekov

Yjq 想要将一个长为 宽为 的矩形棺材（棺材表面绝对光滑，所以棺材可以任意的滑动）拖过一个 L 型墓道。

如图所示，L 型墓道两个走廊的宽度分别是 和 ，呈 90°，并且走廊的长度远大于 。

现在 Hja 想知道对于给定的a ,  b, l，最大的 是多少，如果无论如何棺材都不可能通过，则输出"My poor head =("

【输入格式】

第一行三个用空格分隔的整数a , b , l，意义如题目所示。

【输出格式】

输出最大的可能的 w，保留七位小数，如果无论如何棺材都不可能通过，则输出"My poor head =("。

【样例输入 1】

2 2 1

【样例输出 1】

1.0000000

【样例输入 2】

2 2 2

【样例输出 2】

2.0000000

【样例输入 3】

2 2 3

【样例输出 3】

1.3284271

【样例输入 4】

2 2 6

【样例输出 4】

My poor head =(

【数据范围与规定】

对于100%的数据，1 ≤  a,b  l,≤ 10⁴。

 

设直线解析式为 y=（-n/m）* x+n

整理，得：n * x + m * y - n * m = 0

点（b，a）到直线的距离为：|  b * n + a * m - n * m | / L

(L : 根号下（n^2 + m^2）=L)

棺材能够在这里拐弯

直观上感受就是棺材拐弯的全程不被点（b，a）卡住

所以 最优解 是  b * n + a * m - n * m / L 的最小值

为什么这里把绝对值去掉？

因为 当式子<0 时，直线到了点的右上方，就是不合法解，此时棺材不能通过

单峰函数求最小值，三分法每次去掉大的一部分

注意特判直接横着/竖着就能拖过去的情况

 

#include<algorithm>
#include<cstdio>
#include<cmath>

using namespace std;
const double eps=1e-9;

int a,b,l;

double f(double n)
{
    double m=sqrt(1.0*l*l-n*n);
    return (b*n+a*m-n*m)/l;
}

int main()
{
    freopen("b.in","r",stdin);
    freopen("b.out","w",stdout);
    scanf("%d%d%d",&a,&b,&l);
    if(a>=l && b>=l) { printf("%d.0000000",l); return 0; }
    if(a>=l) { printf("%d.0000000",b); return 0; }
    if(b>=l) { printf("%d.0000000",a); return 0; }
    double L=0,R=l,ans=-1e18,mid1,mid2,t1,t2;
    int T=100;
    while(T--)
    {
        mid1=(R-L)/3+L; mid2=L+R-mid1;
        t1=f(mid1); t2=f(mid2);
        if(t1<0 || t2<0) { printf("My poor head =("); return 0; }
        if(t1<t2) ans=t1,R=mid2;
        else ans=t2,L=mid1;
    }
    printf("%.7lf",ans);
}

T3 c

【问题描述】

你是能看到第三题的 friends 呢。

——aoao

树是个好东西，删掉树一条边要 1 的代价，随便再加一条边有 1 的代价，求最小的代价把树变成环。

【输入格式】

第一行一个整数 N，代表树的点数。

接下来 N− 1行，每行两个数代表树的一条边。

【输出格式】

一行一个整数代表答案。

【样例输入】

4

1 2

2 3

2 4

【样例输出】

3

【数据规模与约定】

对于30%的数据，1 ≤N ≤ 10。对于60%的数据，1 ≤N ≤ 1000。

对于100%的数据，1 ≤ N≤ 100000。

#include <cstdio>
#include <map>

inline void read(int &x)
{
    x=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}

const int N(100005);

std::map<int,bool>cut[N];

int n,cnt[N],ans,tmp;
int head[N],sumedge;
struct Edge {
    int v,next;
    Edge(int v=0,int next=0):v(v),next(next){}
}edge[N<<1];
inline void ins(int u,int v)
{
    cnt[u]++; cnt[v]++;
    edge[++sumedge]=Edge(v,head[u]); head[u]=sumedge;
    edge[++sumedge]=Edge(u,head[v]); head[v]=sumedge;
}

int tim,dfn[N];
inline void Cutedge(int u)
{
    int maxx=-1,pos;
    for(int v,i=head[u]; i; i=edge[i].next)
    {
        v=edge[i].v;
        if(cnt[v]>maxx&&!cut[u][v]&&!cut[v][u]) maxx=cnt[v],pos=v;
    }
    cnt[pos]--; cut[u][pos]=cut[pos][u]=1;
}
void DFS(int u)
{
    dfn[u]=++tim;
    for(int v,i=head[u]; i; i=edge[i].next)
    {
        v=edge[i].v;
        if(!cut[u][v]&&!cut[v][u]&&!dfn[v]) DFS(v);
    }
}

int Presist()
{
//    freopen("c.in","r",stdin);
//    freopen("c.out","w",stdout);
    read(n);
    for(int u,v,i=1; i<n; ++i)
        read(u),read(v),ins(u,v);
    for(int i=1; i<=n; ++i)
      for(; cnt[i]>2; cnt[i]--)
        Cutedge(i),ans++;
    for(int i=1; i<=n; ++i)
        if(!dfn[i]) DFS(i),ans++;
    printf("%d
",ans);
    return 0;
}

int Aptal=Presist();
int main(int argc,char**argv){;}

贪心处理每个节点，当一个点的度数>2时，一定需要删去一条父边，这个点对答案的贡献是 cnt[i]-2<<1，

要求是一条链，所以多出的边都应删去，一个环的总边数不变，删去的边一定会在累加上，所以*2

#include <cstdio>

inline void read(int &x)
{
    x=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}

const int N(100005);

int n,cnt[N],ans;
int head[N],sumedge;
struct Edge {
    int v,next;
    Edge(int v=0,int next=0):v(v),next(next){}
}edge[N<<1];
inline void ins(int u,int v)
{
    cnt[u]++; cnt[v]++;
    edge[++sumedge]=Edge(v,head[u]); head[u]=sumedge;
    edge[++sumedge]=Edge(u,head[v]); head[v]=sumedge;
}

void DFS(int u,int pre)
{
    for(int v,i=head[u]; i; i=edge[i].next)
    {
        v=edge[i].v;
        if(v==pre) continue;
        DFS(v,u);
        if(cnt[v]>2)
        {
            cnt[u]--;
            ans+=cnt[v]-2<<1;
        }
    }
}

int Presist()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);
    read(n);
    for(int u,v,i=1; i<n; ++i)
        read(u),read(v),ins(u,v);
    for(int i=1; i<=n; ++i)
        if(cnt[i]==1) { DFS(i,0); break; }
    printf("%d
",ans+1);
    return 0;
}

int Aptal=Presist();
int main(int argc,char**argv){;}