2013 ACM-ICPC吉林通化全国邀请赛

最新推荐文章于 2021-03-29 15:48:54 发布

programmy

最新推荐文章于 2021-03-29 15:48:54 发布

阅读量504

点赞数

分类专栏：套题文章标签： acm-icpc

本文链接：https://blog.csdn.net/mmy1996/article/details/53196583

版权

套题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

2013 ACM-ICPC吉林通化全国邀请赛——题目重现

D题HDU4496-D -City【并查集+逆向思考】

题目大意

n个点，m条边，按照输入边的顺序一条一条地删去，每删一条询问当前的连通分量数目。

分析

它的逆向过程就是每加入一条边就将两个点所在的集合合并，用并查集来维护。

代码


#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
using namespace std;
int n,m;
int pa[100005];
int ans[1000005];
struct Edge
{
      int x;
      int y;
}edge[1000005];
void Init()
{
      for(int i=0;i<n;i++)
        pa[i]=i;
}
int Findset(int i)
{
      if(pa[i]!=i)
        pa[i]=Findset(pa[i]);
        return pa[i];
}
void Union(int a,int b)
{
      pa[a]=b;
}
int main()
{
  while(scanf("%d%d",&n,&m)!=EOF)
  {
      Init();
      for(int i=1;i<=m;i++)
      {
          scanf("%d%d",&edge[i].x,&edge[i].y);
      }
      ans[m]=n;
      for(int i=m;i>=1;i--)
      {
          if(Findset(edge[i].x)!=Findset(edge[i].y))
          {
              ans[i-1]=ans[i]-1;
              Union(Findset(edge[i].x),Findset(edge[i].y));
          }
                    else
            ans[i-1]=ans[i];
      }
      for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
  }

}

E题HDU4497-GCD and LCM 【数论质因子】

题目大意

给出G、L，问有多少对(x,y,z)满足

${g c d (x, y, z) = G l c m (x, y, z) = L$ $\begin{cases}gcd(x,y,z)=G\\ lcm(x,y,z)=L \end{cases}$

分析

1.因为gcd、lcm都和素数有关，将这些数都化为素数成积的形式

$⎧ ⎩ ⎨ ⎪ ⎪ x = p a 1 1 p a 2 2 . . . p a n n y = p b 1 1 p b 2 2 . . . p b n n z = p c 1 1 p c 2 2 . . . p c n n$ $\begin{cases} x=p_1^{a_1}p_2^{a_2}...p_n^{a_n}\\ y=p_1^{b_1}p_2^{b_2}...p_n^{b_n}\\ z=p_1^{c_1}p_2^{c_2}...p_n^{c_n} \end{cases}$
又有
${G = p m 1 1 p m 2 2 . . . p m n n L = p k 1 1 p k 2 2 . . . p k n n$ $\begin{cases} G=p_1^{m_1}p_2^{m_2}...p_n^{m_n}\\ L=p_1^{k_1}p_2^{k_2}...p_n^{k_n} \end{cases}$
2.
由gcd和lcm性质可知
${m i = m i n {a i, b i, c i} k i = m a x {a i, b i, c i}$ $\begin{cases} m_i=min\{a_i,b_i,c_i\}\\ k_i=max\{a_i,bi,c_i\} \end{cases}$
3.
现在就是排列组合的问题了， $p_i$ 和 $p_j$ 之间是独立的分类计数，直接算分两种情况：
$⎧ ⎩ ⎨ m i = k i : 1 m i \neq k i : A 33 * (k i - m i - 1) + 2 * A 3 3 A 2 2 = A 33 * (k i - m i)$ $\begin{cases} m_i=k_i:1\\ m_i \neq k_i:A_3^3*(k_i-m_i-1)+2*\frac{A_3^3}{A_2^2}=A_3^3*(k_i-m_i) \end{cases}$
一个技巧是令M= $\frac{L}{G}$
$M = P k 1 - m 1 1 P k 2 - m 2 2 . . . P k n - m n n$ $M=P_1^{k_1-m1}P_2^{k_2-m_2}...P_n^{k_n-m_n}$
这样就用算M的质因数，并省去了判断 $m_i是$ 否等于 $k_i$

代码

#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
using namespace std;
#define MAXN 50000
int T;
int G,L;
int prime[100005];
int CNT;
int ans;
struct  P
{
      int m;
      int c;
}p[100005];
void Find_prime()
{
      int notprime[100005];
      memset(notprime,0,sizeof(notprime));
      int cnt=0;
      for(int i=2;i<=100000;i++)
      {
          if(!notprime[i])prime[++cnt]=i;
          for(int j=1;i*prime[j]<=100000;j++)
          {
              notprime[i*prime[j]]=1;
              if(i%prime[j]==0)break;
          }
      }
}
void FindP(int M)
{
      int i=1;
    CNT=0;
      while(M>1)
      {
          if(prime[i]*prime[i]>M)
          {
              CNT++;
              p[CNT].m=M;
              p[CNT].c=1;
              return ;
          }
          if(M%prime[i]==0)
          {
              CNT++;
              p[CNT].m=prime[i];
              p[CNT].c=0;
              while(M%prime[i]==0) {p[CNT].c++;M/=prime[i];}
          }
          i++;
      }
}
int main()
{
   Find_prime();
   int M;
   cin>>T;

   while(T--)
   {
      cin>>G>>L;
      if((L%G)!=0){cout<<0<<endl;continue;}
      M=L/G;
      FindP(M);
       ans=1;
      for(int i=1;i<=CNT;i++)
      {
          ans*=(6*p[i].c);
      }
      cout<<ans<<endl;
   }
}

H题HDU4597-Play Game【区间动规】

题目大意

两排长度为n的数列，Alice和Bob轮流取数（足够聪明）
每次只能从4个端点中的一个取，问先取的人能取到的最大数是多少

分析

我的方法好像不是简洁，有空再改。
$f[x_1][y_1][x_2][y_2]$ 表示第一排从 $x_1$ 到 $y_1$ ，第二排从 $x_2$ 到 $y_2$ 先取的人（Alice）所能取到的最大数$
状态确定了之后就是状态的转移方程了，类似于最长公共子序列问题(LCS)，就不多说了。

代码

#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
using namespace std;
int T;
int n;
int a[25];
int b[25];
int f[25][25][25][25];
int sum[25][25][25][25];
int sa[25];
int sb[25];
int max(int a,int b)
{
     return a>b ?a : b;
}
void Init()
{
      for(int i=1;i<=n;i++)
      {
          sa[i]=sa[i-1]+a[i];
          sb[i]=sb[i-1]+b[i];
      }
      memset(f,0,sizeof(f));
}
int Sum(int L1,int R1,int L2,int R2)
{
      return sa[R1]-sa[L1-1]+sb[R2]-sb[L2-1];
}
int F(int L1,int R1,int L2,int R2)
{
      if(L1>R1 && L2>R2)return 0;
      if(f[L1][R1][L2][R2]!=0)return f[L1][R1][L2][R2];
      int ans=0;
      if(L1<=R1)
      {
        ans=max( Sum(L1,R1,L2,R2)- F(L1+1,R1,L2,R2) ,ans);
          ans=max( Sum(L1,R1,L2,R2)- F(L1,R1-1,L2,R2) ,ans);
      }
        if(L2<=R2)
        {
          ans=max( Sum(L1,R1,L2,R2)- F(L1,R1,L2+1,R2) ,ans);
          ans=max( Sum(L1,R1,L2,R2)- F(L1,R1,L2,R2-1) ,ans );
        }
      return f[L1][R1][L2][R2]=ans;
}
int main()
{
  cin>>T;
  while(T--)
  {
      cin>>n;
      for(int i=1;i<=n;i++)
          cin>>a[i];
            for(int i=1;i<=n;i++)
              cin>>b[i];
            Init();
            cout<<F(1,n,1,n)<<endl;
  }
}

programmy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2013 ACM-ICPC吉林通化全国邀请赛

2013 ACM-ICPC吉林通化全国邀请赛——题目重现D题HDU4496-D -City【并查集+逆向思考】题目大意 n个点，m条边，按照输入边的顺序一条一条地删去，每删一条询问当前的连通分量数目。分析它的逆向过程就是每加入一条边就将两个点所在的集合合并，用并查集来维护。代码#include<iostream>#include<cstring>#include<cmath>#inc
复制链接

扫一扫