AtCoder Beginner Contest 248(D，E，F)

合集 - acm(93)

29.AtCoder Beginner Contest 248(D，E，F) 2023-05-14

AtCoder Beginner Contest 248(D，E，F)

D （思维，二分)

这个题大意就是给你 $n$ 个数，然后有 $q$ 次询问，问 $l$ 到 $r$ 这个区间等于 $x$ 的数有多少个

这个我之前想过用树状数组，每一个数都会建一颗数，但是我发现这不现实

后来看了题解，发现一个了一个的很好的办法

它也是为每一个数都创建一个东西，但不是数，而是一个 $v e c t o r$ ，里面存的是这个数的位置，因为我们是正序遍历的，那么这个数组里面的数也是有序的，然后我们要求这个范围里面的这个数有多少个，不妨转化为这一个数有多少个位置是在这个范围里面的，刚好，每一个数我们都把他的位置有序的保存下来了，所以我们就直接可以 $upper__bound-lower__bound$ 了

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include<cmath>
#include <unordered_map>
#include <array>
#include <cstring>
using namespace std;
#define int long long 
#define LL long long
#define ios  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define inf 1e18
#define INF 1e18
#define mem(a,b) memset((a),(b),sizeof(a))
const double eps=1e-9;
const int maxn=2e5+10;
int n,q;
vector<int>x[maxn];
signed main() 
{
   cin>>n;
   for (int i=1;i<=n;i++)
   {
      int num;
      cin>>num;
      x[num].push_back(i);
   }
   cin>>q;
   while (q--)
   {
      int l,r,num;
      cin>>l>>r>>num;
      int ans=upper_bound(x[num].begin(),x[num].end(),r)-lower_bound(x[num].begin(),x[num].end(),l);
      cout<<ans<<"\n";
   }
   system ("pause");
    return 0;
}

E (几何，组合问题，容斥)

这个题大意就是给你 $n$ 个点，任意 $k$ 个点可以组成多少条直线

但是这个题我们还要特判一下，如果 $k$ 是 $1$ 的话，那么就有无限个点了，直接输出

首先我们要知道两点之间一定有一条直线，我们可以先固定这一条直线，然后再来寻找这一条直线里面还有多少其实的点

但是对于一条直线上的，如果存在 $c n t$ 个点，那么它就会用来计算 $\frac{c n t \times (c n t - 1)}{2}$ 次，当实际上我们只要计算一次即可，所以，对于我们记录已有的答案 $c n t$ 时，还需要除去那些多计算的次数

还有，我们需要知道怎么判断这三个点是否在一条直线上

假设点 $a$ 为 $(x 1, y 1)$ ,点 $b$ 为 $(x 2, y 2)$ ,点 $c$ 为 $(x 3, y 3)$

f l a g = (x 1 - x 2) \times (y 1 - y 3) - (x 1 - x 3) \times (y 1 - y 2)

如果上面这个 $f l a g$ 等于 $0$ ,那么这三个点共线

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include<cmath>
#include <unordered_map>
#include <array>
#include <cstring>
using namespace std;
#define int long long 
#define LL long long
#define ios  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define inf 1e18
#define INF 1e18
#define mem(a,b) memset((a),(b),sizeof(a))
const double eps=1e-9;
const int maxn=2e5+10;
int n,k;
int cnt[maxn];
struct node
{
   int x,y;
}a[maxn];
bool check(int i,int j,int k)
{
   int tx1=a[i].x-a[j].x,tx2=a[i].x-a[k].x;
   int ty1=a[i].y-a[j].y,ty2=a[i].y-a[k].y;
   if(tx1*ty2==tx2*ty1) return true;
   return false;
}
signed main() 
{
   cin>>n>>k;
   for (int i=1;i<=n;i++)
   {
      cin>>a[i].x>>a[i].y;
   }
   if(k==1)
   {
      cout<<"Infinity\n";
      system ("pause");
      return 0;
   }
   for (int i=1;i<=n;i++)
   {
      for (int j=i+1;j<=n;j++)
      {
         int res=2;
         for (int k=1;k<=n;k++)
         {
            if(i==k||j==k) continue;
            if(check(i,j,k))
            {
               res++;
            }
         }
         cnt[res]++;
      }
   }
   int ans=0;
   for (int i=k;i<=n;i++)
   {
      int tmp=i*(i-1)/2;
      ans=ans+cnt[i]/tmp;
   }
   cout<<ans<<"\n";
   system ("pause");
    return 0;
}

F(dp)

这个题题我是这样理解的，给你 $n$ ,然后会有一个 $2 \times n$ 的点，这些点最开始都会和他们相邻的点连接，问有多少个方式删除 $i$ 个边后，这些点都还是连通的

对于这一个题，我们可以设计一个状态 $d p [i] [j] [k]$ ,代表前 $i$ 个点，删除了 $j$ 个点，其连通性是 $k$ .( $0$ 是非连通， $1$ 是连通)

然后对于状态之间的转移，我们有以下规律

然后我们就可以很轻松的得到状态转移方程

 for (int p1=0;p1<2;p1++)
 {
     for (int p2=0;p2<2;p2++)
       {
         for (int p3=0;p3<2;p3++)
            {
             if(k==0)//p1,p2是邻边，p3是对边，如果这一条边没有连接，要想保持连通性，两个邻边必须都存在
             {
                 if(p1==0||p2==0) continue;
                  int nxtj=j+1-p3;
                   add(dp[i+1][nxtj][p3],dp[i][j][k]);
             }
             else if(k==1)//p1,p2至少有一个，要连通
             {
                 if(p1==0&&p2==0) continue;
                 int nxtj=j+3-(p1+p2+p3);
                 int nxtk=(p1+p2+p3)>=2;
                 add(dp[i+1][nxtj][nxtk],dp[i][j][k]);
             }
         }
     }
 }

然后在这一道题的初状态我还有了一个更新理解（我之前可能还是一知半解），对于初状态，并不意味它一定是我们可以选择的，但是一定可以存在的

如这个题的初状态， $d p [0] [1] [0]$ ,对于删除了一条边之后，它一定是不连通的，这个状态是存在的， $d p [0] [0] [1]$ ,对于没有删除了一条边，它一定是连通的，这个状态是存在的，而且都只有一种方式

感觉说了又好像没说，感觉这个看个人的理解吧

而且，我在这里第一次使用了 $a d d$ ,我发现取模运算比起加减运算，时间效率不高，反正，取模的时间效率比起其他一般的运算都比较低。难怪好多次看到其他人的代码里面有这个，还有之前求奇偶数也不是用取模，而是且运算，看来是这样的

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include<cmath>
#include <unordered_map>
#include <array>
#include <cstring>
using namespace std;
#define int long long 
#define LL long long
#define ios  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define inf 1e18
#define INF 1e18
#define mem(a,b) memset((a),(b),sizeof(a))
const double eps=1e-9;
const int maxn=3000+10;
int n,mod;
int dp[maxn][maxn][2];
void add(int &x,int v)
{
   x+=v;
   if(x>mod)
   {
      x-=mod;
   }
   return ;
}
signed main() 
{
   cin>>n>>mod;
   dp[0][1][0]=1;
   dp[0][0][1]=1;
   for (int i=0;i<n;i++)
   {
      for (int j=0;j<n;j++)
      {
         for (int k=0;k<2;k++)
         {
            if(dp[i][j][k]==0) continue;
            for (int p1=0;p1<2;p1++)
            {
               for (int p2=0;p2<2;p2++)
               {
                  for (int p3=0;p3<2;p3++)
                  {
                     if(k==0)//p1,p2是邻边，p3是对边，如果这一条边没有连接，要想保持连通性，两个邻边必须都存在
                     {
                        if(p1==0||p2==0) continue;
                        int nxtj=j+1-p3;
                        add(dp[i+1][nxtj][p3],dp[i][j][k]);
                     }
                     else if(k==1)//p1,p2至少有一个，要连通
                     {
                        if(p1==0&&p2==0) continue;
                        int nxtj=j+3-(p1+p2+p3);
                        int nxtk=(p1+p2+p3)>=2;
                        add(dp[i+1][nxtj][nxtk],dp[i][j][k]);
                     }
                  }
               }
            }
         }
      }
   }
   for (int i=1;i<n;i++)
   {
      cout<<dp[n-1][i][1]<<" ";
   }
   system ("pause");
    return 0;
}

posted @ 2023-05-14 21:41 righting 阅读(5) 评论(0) 编辑收藏举报

righting

AtCoder Beginner Contest 248(D，E，F)

AtCoder Beginner Contest 248(D，E，F)

D （思维，二分)

E (几何，组合问题，容斥)

F(dp)

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

合集 (1)

随笔分类 (95)

随笔档案 (95)

相册 (1)

阅读排行榜

评论排行榜

推荐排行榜

最新评论