qbxt 考前集训 Day1

立方数(cubic)

Time Limit:1000ms Memory Limit:128MB

题目描述

LYK定义了一个数叫“立方数”，若一个数可以被写作是一个正整数的3次方，则这个数就是立方数，例如1,8,27就是最小的3个立方数。

现在给定一个数P，LYK想要知道这个数是不是立方数。

当然你有可能随机输出一些莫名其妙的东西来骗分，因此LYK有T次询问~

输入格式(cubic.in)

第一行一个数T，表示有T组数据。

接下来T行，每行一个数P。

输出格式(cubic.out)

输出T行，对于每个数如果是立方数，输出“YES”，否则输出“NO”。

输入样例

输出样例

YES

数据范围

对于30%的数据p<=100。

对于60%的数据p<=10^6。

对于100%的数据p<=10^18，T<=100。

思路：依题意模拟，注意精度，注意精度，注意精度！

转换为long long防止被卡精度的方法：(long long)(something+eps)

eps为一个非常小的值（1e-6~1e-11）

正解直接1-1e6枚举判断，少了精度问题。

 #include<cstdio>

 #include<cmath>

 using namespace std;

 long long t,n;

 double res;

 long long chk;

 const double cube=0.33333333333333333333333333333333333333333333333333333;

 const double eps=1e-;

 int main()

 {

     freopen("cubic.in","r",stdin);

     freopen("cubic.out","w",stdout);

     scanf("%I64d",&t);

     for(int i=;i<t;i++)

     {

         scanf("%I64d",&n);

         res=pow(n,cube)+eps;//防止被卡精度

         chk=res;

         if(pow(chk,)==n)printf("YES\n");

         else printf("NO\n");

     }

     fclose(stdin);

     fclose(stdout);

     return ;

 }

my - 100pts

被精度卡了半个小时。

立方数2(cubicp)

Time Limit:1000ms Memory Limit:128MB

题目描述

LYK定义了一个数叫“立方数”，若一个数可以被写作是一个正整数的3次方，则这个数就是立方数，例如1,8,27就是最小的3个立方数。

LYK还定义了一个数叫“立方差数”，若一个数可以被写作是两个立方数的差，则这个数就是“立方差数”，例如7(8-1),26(27-1),19(27-8)都是立方差数。

现在给定一个数P，LYK想要知道这个数是不是立方差数。

当然你有可能随机输出一些莫名其妙的东西，因此LYK有T次询问~

这个问题可能太难了…… 因此LYK规定P是个质数！

输入格式(cubicp.in)

第一行一个数T，表示有T组数据。

接下来T行，每行一个数P。

输出格式(cubicp.out)

输出T行，对于每个数如果是立方差数，输出“YES”，否则输出“NO”。

输入样例

输出样例

YES

数据范围

对于30%的数据p<=100。

对于60%的数据p<=10^6。

对于100%的数据p<=10^12，T<=100。

思路：立方差公式的运用。

立方差公式：

\begin{equation*}a^3-b^3=(a-b)(a^2+ab+b^2)\end{equation*}

因为是素数，所以可以设$a-b=1$，容易得到$a=b+1$，带回原式，得到$(b+1)^2+[(b+1)\times b]+b^2$，化简即可得到$3\times x^2-3\times x+1$。

观察这个式子具有单调性，所以可以二分。当然枚举也行。

code

 #include <algorithm>

 #include <cstdio>

 typedef long long LL;

 LL cubeps[];

 int main() {

   freopen("cubicp.in", "r", stdin);

   freopen("cubicp.out", "w", stdout);

     for (LL i = ; i <= ; ++i)

     cubeps[i - ] =  * i * i +  * i + ;

   int T;

   LL n;

   scanf("%d", &T);

   while (T--) {

     scanf("%I64d", &n);

     puts(*std::lower_bound(cubeps, cubeps + , n) == n ? "YES" : "NO");

   }

   return ;

 }

std

 #include<cstdlib>

 #include<cstdio>

 #include<ctime>

 #include<set>

 using namespace std;

 long long table[]={,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,};

 set<long long> s;

 long long t,n;

 bool preprocessed;

 inline void preprocess()

 {

     for(int i=;i<sizeof(table)/sizeof(long long);i++)

         s.insert(table[i]);

     preprocessed=true;

 }

 inline void test(long long n)

 {

     if(preprocessed==false)preprocess();

     if(s.count(n)==)printf("YES\n");

     else printf("NO\n");

 }

 int main()

 {

     srand(time(NULL));

     freopen("cubicp.in","r",stdin);

     freopen("cubicp.out","w",stdout);

     for(int i=;i<;i++)

         s.insert(table[i]);

     scanf("%d",&t);

     for(int i=;i<t;i++)

     {

         scanf("%I64d",&n);

         if(n<=)test(n);

         else printf(rand()%?"YES\n":"NO\n");

     }

     fclose(stdin);

     fclose(stdout);

     return ;

 }

my - 60pts

猜数字(number)

Time Limit:1000ms Memory Limit:128MB

题目描述

LYK在玩猜数字游戏。

总共有n个互不相同的正整数，LYK每次猜一段区间的最小值。形如[li,ri]这段区间的数字的最小值一定等于xi。

我们总能构造出一种方案使得LYK满意。直到…… LYK自己猜的就是矛盾的！

例如LYK猜[1,3]的最小值是2，[1,4]的最小值是3，这显然就是矛盾的。

你需要告诉LYK，它第几次猜数字开始就已经矛盾了。

输入格式(number.in)

第一行两个数n和T，表示有n个数字，LYK猜了T次。
接下来T行，每行三个数分别表示li,ri和xi。

输出格式(number.out)

输出一个数表示第几次开始出现矛盾，如果一直没出现矛盾输出T+1。

输入样例

20 4

1 10 7

5 19 7

3 12 8

1 20 1

输出样例

数据范围

对于50%的数据n<=8，T<=10。

对于80%的数据n<=1000，T<=1000。

对于100%的数据1<=n,T<=1000000,1<=li<=ri<=n,1<=xi<=n（但并不保证一开始的所有数都是1~n的）。

Hint

建议使用读入优化

inline int read()

{

int
x = 0, f = 1;

char
ch = getchar();

for(;
!isdigit(ch); ch = getchar()) if(ch == '-') f = -1;

for(;
isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';

return
x * f;

}

思路：打了个暴力，但是只有20.

正解：二分答案，用并查集维护集合的关系。

正确性证明：

两个猜测的最小值如果相同的话那么这个最小值一定在这两个线段的交上

否则，一定在这两个线段的交集关于全集的补集上

当产生冲突的时候一定是权值小的一次猜测被几条比他权值大的猜测完全覆盖，

那么我们可以二分第几次不满足要求，用并查集维护线段的覆盖。

时间复杂度$O(n\log n\times \alpha (n))$.

 #include <cstdio>

 #include <iostream>

 #include <algorithm>

 #define N 1000011

 #define min(x, y) ((x) < (y) ? (x) : (y))

 #define max(x, y) ((x) > (y) ? (x) : (y))

 using namespace std;

 int n, q, ans;

 int f[N];

 struct node

 {

     int x, y, z;

 }p[N], t[N];

 inline int read()

 {

     int x = , f = ;

     char ch = getchar();

     for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -;

     for(; isdigit(ch); ch = getchar()) x = (x << ) + (x << ) + ch - '';

     return x * f;

 }

 inline bool cmp(node x, node y)

 {

     return x.z > y.z;

 }

 inline int find(int x)

 {

     return x == f[x] ? x : f[x] = find(f[x]);

 }

 inline bool check(int k)

 {

     int i, j, x, y, lmin, lmax, rmin, rmax;

     for(i = ; i <= n + ; i++) f[i] = i;

     for(i = ; i <= k; i++) t[i] = p[i];

     std::sort(t + , t + k + , cmp);

     lmin = lmax = t[].x;

     rmin = rmax = t[].y;

     for(i = ; i <= k; i++)

     {

         if(t[i].z < t[i - ].z)

         {

             if(find(lmax) > rmin) return ;

             for(j = find(lmin); j <= rmax; j++)

                 f[find(j)] = find(rmax + );

             lmin = lmax = t[i].x;

             rmin = rmax = t[i].y;

         }

         else

         {

             lmin = min(lmin, t[i].x);

             lmax = max(lmax, t[i].x);

             rmin = min(rmin, t[i].y);

             rmax = max(rmax, t[i].y);

             if(lmax > rmin) return ;

         }

     }

 //    cout<<find(1)<<endl;

     if(find(lmax) > rmin) return ;

     return ;

 }

 int main()

 {

     freopen("number.in","r",stdin);

     freopen("number.out","w",stdout);

     int i, x, y, mid;

     n = read();

     q = read();

     for(i = ; i <= q; i++)

         p[i].x = read(), p[i].y = read(), p[i].z = read();

     x = , y = q;

     //cout<<check(2)<<endl;

     //return 0;

     ans = q + ;

     while(x <= y)

     {

         mid = (x + y) >> ;

         if(check(mid)) ans = mid, y = mid - ;

         else x = mid + ;

     }

     printf("%d\n", ans);

     return ;

 }

std

水题(water)

Time Limit:1000ms Memory Limit:128MB

题目描述

LYK出了道水题。

这个水题是这样的：有两副牌，每副牌都有n张。

对于第一副牌的每张牌长和宽分别是xi和yi。对于第二副牌的每张牌长和宽分别是aj和bj。第一副牌的第i张牌能覆盖第二副牌的第j张牌当且仅当xi>=aj并且yi>=bj。（注意牌不能翻转）当然一张牌只能去覆盖最多一张牌，而不能覆盖好多张。

LYK想让两副牌的各n张一一对应叠起来。它想知道第二副牌最多有几张能被第一副牌所覆盖。

输入格式(water.in)

第一行一个数n。

接下来n行，每行两个数xi,yi。

接下来n行，每行两个数aj,bj。

输出格式(water.out)

输出一个数表示答案。

输入样例

2 3

5 7

6 8

4 1

2 5

3 4

输出样例

数据范围

对于50%的数据n<=10。

对于80%的数据n<=1000。

对于100%的数据1<=n<=100000，1<=xi,yi,aj,bj<=10^9。

思路：

50pts n! 枚举。

80pts 网络流二分图匹配。

80pts 贪心。

普通贪心？考虑A_1=(x[i],y[i]); B_1(x[i],1), B_2(1,y[i])的情况，此时二者都优。

对x[i]进行排序，每次遇到B类牌，将y值插入进某个数据结构中。遇到A类牌，找这个数据结构中y值尽可能大且不超过这张牌的y值。数组实现，n^2暴力维护。

100pts 考虑这个数据结构的操作。

插入一个数
删除不超过y最大的数

=> 平衡树、权值线段树+离散化、multiset

 #include <stdio.h>

 #include <string.h>

 #include <algorithm>

 #include <iostream>

 #include <set>

 using namespace std;

 int n;

 multiset <int> s;

 struct node {int x,y;} a[],b[];

 int cmp(node i,node j) {return i.x<j.x;}

 int main()

 {

     freopen("water.in","r",stdin);

     freopen("water.out","w",stdout);

     int T;

     T=;

     while(T--)

     {

         scanf("%d",&n);

         for(int i=;i<n;i++) scanf("%d%d",&a[i].x,&a[i].y);

         for(int i=;i<n;i++) scanf("%d%d",&b[i].x,&b[i].y);

         sort(a,a+n,cmp);

         sort(b,b+n,cmp);

         s.clear();

         int k=,ans=;

         for(int i=;i<n;i++)

         {

             while(a[i].x>=b[k].x&&k<n)

             {

                  s.insert(b[k].y);

                  k++;

             }

             if(s.empty())continue;

             multiset<int>::iterator it=s.upper_bound(a[i].y);

             if (it==s.begin()) continue; it--;

             ans++; s.erase(it);

         }

         printf("%d\n",ans);

     }

     return ;

 }

std

梦境(dream)

Time Limit:1000ms Memory Limit:128MB

题目描述

LYK做了一个梦。

这个梦是这样的，LYK是一个财主，有一个仆人在为LYK打工。

不幸的是，又到了月末，到了给仆人发工资的时间。但这个仆人很奇怪，它可能想要至少x块钱，并且当LYK凑不出恰好x块钱时，它不会找零钱给LYK。

LYK知道这个x一定是1~n之间的正整数。当然抠门的LYK只想付给它的仆人恰好x块钱。但LYK只有若干的金币，每个金币都价值一定数量的钱（注意任意两枚金币所代表的钱一定是不同的，且这个钱的个数一定是正整数。LYK想带最少的金币，使得对于任意x，都能恰好拼出这么多钱。并且LYK想知道有多少携带金币的方案总数。

具体可以看样例。

输入格式(dream.in)

第一行一个数n，如题意所示。

输出格式(dream.out)

输出两个数，第一个数表示LYK至少携带的金币个数，第二数表示方案总数。

输入样例

输出样例

3 2

样例解释

LYK需要至少带3枚金币，有两种方案，分别是{1,2,3}，{1,2,4}来恰好得到任意的1~n之间的x。

输入样例2

输出样例2

4 8

数据范围

对于30%的数据n<=10。

对于60%的数据n<=100。

对于100%的数据n<=1000。

思路：

DP/搜索

第一问：打表找规律即可

第二问：直接搜索或者DP。

dfs(Max,Sum,S)//Max金币最大值，Sum所有金币的和，S金币的数量。

{

    if(S==X)

    if(Sum>=n)

        ans++;

    return;

    for(int i=Max+;i<=Sum+;i++)

        dfs(i,Sum+I,S+);

}

DP？直接转化dfs。

优化：前缀和优化（$n\log ^3 n$ -> $n\log ^2 n$ ）

剪枝：if(dp[i][j][k])/*do something*/

 #include <cmath>

 #include <cstdio>

 #include <cstdlib>

 #include <iostream>

 #include <algorithm>

 using namespace std;

 int n,sum,ans,dp[][],DP[][],i,j,k,l;

 int main()

 {

     freopen("dream.in","r",stdin);

     freopen("dream.out","w",stdout);

     scanf("%d",&n);

     sum=int(log(n)/log()+0.000000001)+;

     dp[][]=;

     for (i=; i<sum; i++)

     {

         for (j=; j<=n; j++)

           for (k=; k<=n; k++)

             if (dp[j][k])

               for (l=k+; l<=j+; l++)

                 DP[min(n,j+l)][l]+=dp[j][k];

         for (j=; j<=n; j++) for (k=; k<=n; k++) {dp[j][k]=DP[j][k];DP[j][k]=;}

     }

     for (j=; j<=n; j++) ans+=dp[n][j];

     cout<<sum<<' '<<ans;

     return ;

 }

std

动态规划(dp)

Time Limit:1000ms Memory Limit:128MB

题目描述

LYK在学习dp，有一天它看到了一道关于dp的题目。

这个题目是这个样子的：一开始有n个数，一段区间的价值为这段区间相同的数的对数。我们想把这n个数切成恰好k段区间。之后这n个数的价值为这k段区间的价值和。我们想让最终这n个数的价值和尽可能少。

例如6个数1,1,2,2,3,3要切成3段，一个好方法是切成[1],[1,2],[2,3,3]，这样只有第三个区间有1的价值。因此这6个数的价值为1。

LYK并不会做，丢给了你。

输入格式(dp.in)

第一行两个数n,k。

接下来一行n个数ai表示这n个数。

输出格式(dp.out)

一个数表示答案。

输入样例

10 2

1 2 1 2 1 2 1 2 1 2

输出样例

数据范围

对于30%的数据n<=10。

对于60%的数据n<=1000。

对于100%的数据1<=n<=100000,1<=k<=min(n,20),1<=ai<=n。

其中有30%的数据满足ai完全相同均匀分布在所有数据中。

题解：

对于最后30%，尽量切成长度相同的区间。

前30%，$2^n$暴力枚举出现的位置。

∑ 50pts

70pts:

dp[i][j] 1~i 切了i刀的最优解。

dp[i][j]=min{dp[k][j-1]+sum(k+1,i)}

k从大到小枚举，每次枚举时更新这个sum。

时间复杂度： $20\times n^2$

100pts:

固定j，随着i的增大，k不会减少。

1D1D动态规划优化。

分治求DP。

 #include<iostream>

 #include<cstdio>

 using namespace std;

 const int N=;

 typedef long long LL;

 int c[N],a[N];

 LL f[N],g[N];

 int p,q,n,k;

 LL tot;

 void move(int l,int r)  // [p,q]之前的区间

 {

     while (l<p) p--,tot+=c[a[p]],c[a[p]]++;

     while (r>q) q++,tot+=c[a[q]],c[a[q]]++;

     while (p<l) c[a[p]]--,tot-=c[a[p]],p++;

     while (r<q) c[a[q]]--,tot-=c[a[q]],q--;

 }

 void work(int l,int r,int fl,int fr)

 //需要求dp[fl] ~ dp[fr]  最优解一定从l~r中的某一个转移过来

 {

     if (fl>fr) return;

     int mid=(fl+fr)>>,mi;

     LL mx=1LL<<;

     for (int i=l;i<=r;i++)

     if (i<mid)

     {

         move(i+,mid); -> tot=sum(i+,mid);

         if (f[i]+tot<mx) mx=f[i]+tot,mi=i;

     }

     g[mid]=mx;

     work(l,mi,fl,mid-);

     work(mi,r,mid+,fr);

 }

 int main()

 {

     freopen("dp.in","r",stdin);

     freopen("dp.out","w",stdout);

     scanf("%d%d",&n,&k);

     for (int i=;i<=n;i++) scanf("%d",&a[i]);

     f[]=;

     for (int i=;i<=n;i++) f[i]=1LL<<;

     while (k--)

     {

         p=,q=,tot=;

         for (int i=;i<=n;i++) c[i]=;

         work(,n-,,n);

         for (int i=;i<=n;i++) f[i]=g[i],g[i]=;

     }

     cout<<f[n];

     return ;

 }

std

总结：

上午发挥还行。180

下午随着题目难度提高，爆零了。

不会的重要算法：二分与贪心。

还是要学会打暴力啊，NOIp暴力分还是很多的。

巴特西

qbxt 考前集训 Day1

最新文章

热门文章