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();
 char s[N],stack[N];
 int top;

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

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

AC

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-;

 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 ; }
     if(a>=l) { printf("%d.0000000",b); return ; }
     if(b>=l) { printf("%d.0000000",a); return ; }
     double L=,R=l,ans=-1e18,mid1,mid2,t1,t2;
     int T=;
     while(T--)
     {
         mid1=(R-L)/+L; mid2=L+R-mid1;
         t1=f(mid1); t2=f(mid2);
         if(t1< || t2<) { printf("My poor head =("); return ; }
         if(t1<t2) ans=t1,R=mid2;
         else ans=t2,L=mid1;
     }
     printf("%.7lf",ans);
 }

AC

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=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }

 const int N();

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

 int n,cnt[N],ans,tmp;
 int head[N],sumedge;
 struct Edge {
     int v,next;
     Edge(int v=,int next=):v(v),next(next){}
 }edge[N<<];
 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=-,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]=;
 }
 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=; i<n; ++i)
         read(u),read(v),ins(u,v);
     for(int i=; i<=n; ++i)
       for(; cnt[i]>; cnt[i]--)
         Cutedge(i),ans++;
     for(int i=; i<=n; ++i)
         if(!dfn[i]) DFS(i),ans++;
     printf("%d\n",ans);
     return ;
 }

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

30分 莫名WA

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

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

 #include <cstdio>

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

 const int N();

 int n,cnt[N],ans;
 int head[N],sumedge;
 struct Edge {
     int v,next;
     Edge(int v=,int next=):v(v),next(next){}
 }edge[N<<];
 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]>)
         {
             cnt[u]--;
             ans+=cnt[v]-<<;
         }
     }
 }

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

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

AC