Codeforces Round #243 (Div. 1)-A,B,C-D

这场CF真是逗了。。。

因为早上7点起的,所以到做CF的时候已经17个小时没有休息了,再加上中午5小时的比赛。

头脑很不清晰。做第一个题的时候差点读成求最大字段和了。然后发现是水体,迅速A掉。

然后开始看了B题,第一遍没有看懂,此时大脑已经看不下去了。然后突然某个群说D是水题。

我去看了一下D,我去,D的题意好简单啊。。。。于是,冥思苦想中。。。。。一直到快要1点

的时候,还是没有结果。。。此时我感觉不行了。。要放弃D,于是,又去看B。仔细读了读题目,

才发现,B题才是真正的水题。。一阵郁闷啊。。

A题:

可以暴力枚举区间,然后枚举去掉几个数。

去数的时候肯定是优先去掉最小的数,然后拿进来最大的。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<vector>
using namespace std;
#define maxn 220000
#define mem(a,b) memset(a,b,sizeof(a))
int a[222];
vector<int>vec;
vector<int>vecc;
int main()
{
    int n,m,ans,i,j,k;
    while(~scanf("%d%d",&n,&m))
    {
        for(i=1;i<=n;i++)scanf("%d",&a[i]);
        ans=a[1];
        for(i=1;i<=n;i++)
        {
            int p=0;
            for(j=i;j<=n;j++)
            {
                vec.clear();
                vecc.clear();
                p=0;
                for(k=i;k<=j;k++)
                {
                    vec.push_back(a[k]);
                    p+=a[k];
                }
                for(k=1;k<=n;k++)
                {
                    if(k<i||k>j)vecc.push_back(a[k]);
                }
                sort(vec.begin(),vec.end());
                sort(vecc.begin(),vecc.end());
                int len=vec.size();
                ans=max(ans,p);
                for(k=1;k<=m&&k<=len&&k<=vecc.size();k++)
                {
                    p-=vec[k-1];
                    p+=vecc[vecc.size()-k];
                    ans=max(ans,p);
                }
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

B题:

这道题目仔细研究下你就会发现,如果想变成合法的,那么任意两行或者两列都是相同或者相反的状态。

那么如果m小与10的话,咱们就枚举第一行的状态。

如果m大于10的话,咱们就枚举哪一列没有被改变。

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstring>
#include<map>
using namespace std;
#define N 251000
#define maxn 110000
#define LL __int64
int maps[220][220];
int c[220];
int r[220];
int dp[220];
int num[220][2];
int number_1(int x)
{
    x=(x& 0x55555555)+((x>>1)& 0x55555555);
    x=(x& 0x33333333)+((x>>2)& 0x33333333);
    x=(x& 0x0F0F0F0F)+((x>>4)& 0x0F0F0F0F);
    x=(x& 0x00FF00FF)+((x>>8)& 0x00FF00FF);
    x=(x& 0x0000FFFF)+((x>>16)& 0x0000FFFF);
    return x;
}
void dos(int n,int m,int ks)
{
    int ans=99999;
    int i,j,k;
    for(k=0;k<(1<<m);k++)
    {
        int ps=0;
        for(i=1;i<=n;i++)
        {
            int p=0;
            for(j=1;j<=m;j++)
            {
                if(maps[i][j]&&(k&(1<<(j-1))))
                {
                    p++;
                }
                else if(!maps[i][j]&&((k&(1<<(j-1)))==0))
                {
                    p++;
                }
            }
            ps+=min(p,m-p);
        }
        ans=min(ans,ps);
    }
    if(ans<=ks)cout<<ans<<endl;
    else cout<<"-1"<<endl;
}
int have[110][110];
void dos2(int n,int m,int ks)
{
    int i,j,k;
    for(i=1;i<=m;i++)
    {
        for(j=1;j<=m;j++)
        {
            for(k=1;k<=n;k++)
            {
                if(maps[k][i]==maps[k][j])have[i][j]++;
            }
        }
    }
    int ans=999;
    for(i=1;i<=m;i++)
    {
        int p=0;
        for(j=1;j<=m;j++)
        {
            p+=min(have[i][j],n-have[i][j]);
        }
        ans=min(ans,p);
    }
    if(ans<=ks)cout<<ans<<endl;
    else cout<<"-1"<<endl;
}
int main()
{
    int n,m,k,i,j;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(c,0,sizeof(c));
        memset(r,0,sizeof(r));
        memset(dp,0,sizeof(dp));
        memset(maps,0,sizeof(maps));
        memset(num,0,sizeof(num));
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=m;j++)
            {
                scanf("%d",&maps[i][j]);
            }
        }
        if(m<=10)
        {
            dos(n,m,k);
        }
        else
        {
            dos2(n,m,k);
        }
    }
    return 0;
}

C 题:

这次的题意真是。。。。不好懂。。

dp[i][j]:在a数组里选到第i个数共选出了j次,对应b数组下标的最小位置。

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 110000
#define INF 99999999
int dp[maxn][330];
vector<int>vec[maxn];
int a[maxn];
int b[maxn];
int sea(int x,int y)
{
    int l=0;
    int r=vec[y].size();
    int mid=(l+r)/2;
    while(l<r)
    {
        if(vec[y][mid]<=x)l=mid+1;
        else r=mid;
        mid=(l+r)/2;
    }
    if(mid==vec[y].size())return INF;
    else return vec[y][mid];
}
int main()
{
    int n,m,s,e;
    int k;
    int i,j;
    while(~scanf("%d%d%d%d",&n,&m,&s,&e))
    {
        k=s/e;
        for(i=0;i<=n;i++)
        {
            vec[i].clear();
            for(j=0;j<=k;j++)dp[i][j]=INF;
        }
        //cout<<"--"<<endl;
        for(i=1;i<=n;i++)scanf("%d",&a[i]);
        for(i=1;i<=m;i++)scanf("%d",&b[i]);
        for(i=1;i<=m;i++)
        {
            vec[b[i]].push_back(i);
        }
        int ans=0;
        dp[0][0]=0;
        for(i=1;i<=n;i++)
        {
            dp[i][0]=0;
            for(j=1;j<=k&&j<=i;j++)
            {
                int x=dp[i-1][j-1];
                int ps=sea(x,a[i]);
                dp[i][j]=min(dp[i-1][j],ps);
                if(j>ans)
                {
                    if(i+dp[i][j]+j*e<=s)
                    {
                        ans=j;
                    }
                }
            }
        }
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=k&&j<=i;j++)
            {
           //     cout<<dp[i][j]<<" ";
            }
           // cout<<endl;
        }
        cout<<ans<<endl;
    }
    return 0;
}

D题:

这道题目分两种情况讨论。

枚举x轴.

1,如果x轴上的点大于sqrt(n);

如果当前枚举到的x轴上的点大于sqrt(n)的话,那么就枚举其它轴上的所有的点,看能不能跟x轴形成一个正方形。

这种点的个数为n^0.5次方个,每一个的时间复杂度n,总时间复杂度为n^1.5

2,如果x轴上的点小与sqrt(n);

枚举这个轴上的任意两个点能不能形成正方行。

这种点的个数为n^0.5次方个,每一个的时间复杂度为(sqrt(n))^2;

综合时间复杂度为O(n^1.5)

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<math.h>
#include<map>
using namespace std;
#define maxn 110000
#define INF 99999999
vector<int>vec[maxn];
bool find(int x,int y)
{
    if(x>=maxn)return false;
    return binary_search(vec[x].begin(),vec[x].end(),y);
}
int main()
{
    int n,i,j,k,x,y;
    while(~scanf("%d",&n))
    {
        for(i=0;i<maxn;i++)vec[i].clear();
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&x,&y);
            vec[x].push_back(y);
        }
        for(i=0;i<maxn;i++)sort(vec[i].begin(),vec[i].end());
        int sq=sqrt(n);
        int ans=0;
        for(i=0;i<maxn;i++)
        {
            int p=vec[i].size();
            if(vec[i].size()==0)continue;
            if(p<sq)
            {
                for(j=0;j<p;j++)
                {
                    for(k=j+1;k<p;k++)
                    {
                        int d=vec[i][k]-vec[i][j];
                        //cout<<"-"<<vec[i][k]<<" "<<vec[i][j]<<endl;
                        if(find(i+d,vec[i][j])&&find(i+d,vec[i][k]))
                        {
                           // cout<<i<<" "<<vec[i][k]<<" "<<vec[i][j]<<endl;
                            ans++;
                        }
                    }
                }
            }
            else
            {
                for(j=i+1;j<maxn;j++)
                {
                    for(k=0;k<vec[j].size();k++)
                    {
                        int d=j-i;
                   //     cout<<"-"<<i<<" "<<j<<" "<<vec[j][k]<<endl;
                        if(find(i,vec[j][k])&&find(j,vec[j][k]+d)&&find(i,vec[j][k]+d))
                        {
                          //  cout<<i<<" "<<j<<" "<<vec[j][k]<<endl;
                            ans++;
                        }
                    }
                }
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

Codeforces Round #243 (Div. 1)-A,B,C-D,码迷,mamicode.com

时间: 2024-08-28 09:55:29

Codeforces Round #243 (Div. 1)-A,B,C-D的相关文章

Codeforces Round #243 (Div. 1)——Sereja and Two Sequences

题目链接 题意:给两个长度分别为n和m的序列,现在有两种操作:1.分别选择两个序列的一个非空前缀,切两个前缀的最后一位相同,删除之,得到1分(只累计),消耗e:2.直接删除两个序列,消耗值定于两个序列之前删除的元素个数之和,并且使得得到的分有效(之前没有有效分) 分析: 首先,问题其实就是转化成,进行若干次操作1,然后进行操作2 还要找到一个判别标准,来评判较优的状态(贪心) 每次的消耗值比较大,其实可以计算出最大的删除次数,这个值不是很大 状态表示: 简单的,一个状态可以表示为串A的位置.串B

Codeforces Round #243 (Div. 2) A. Sereja and Mugs

#include <iostream> #include <vector> #include <algorithm> #include <numeric> using namespace std; int main(){ int n,s; cin >> n >> s; vector<int> a(n); for(int i = 0 ; i < n ; ++ i) cin >> a[i]; sort(a.b

Codeforces Round #243 (Div. 2) B. Sereja and Mirroring

#include <iostream> #include <vector> #include <algorithm> using namespace std; int main(){ int n,m; cin >> n >> m; vector<vector<int> > a(n,vector<int>(m,0)); for(int i = 0; i < n; ++ i){ for(int j = 0 ;

Codeforces Round #243 (Div. 2) C. Sereja and Swaps

思路来源:http://blog.csdn.net/sf____/article/details/24626739 题目给出数据上限为200, 所以可以暴利所有区间. 解题思路: for i in range(n): for j in range(n): create priority_queue for w in range(k): if(Max.top > Min.top) SWAP(Max[element], Min[element]) 暴利枚举所有初始区间 [ i , j ] ,则剩下的

Codeforces Round #243 (Div. 2) C. Sereja and Swaps(优先队列 暴力)

题目 题意:求任意连续序列的最大值,这个连续序列可以和其他的 值交换k次,求最大值 思路:暴力枚举所有的连续序列.没做对是因为 首先没有认真读题,没看清交换,然后,以为是dp或者贪心 用了一下贪心,各种bug不对. 这次用了一下优先队列,以前用的不多,看这个博客又学了一下 AC代码: 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #i

Codeforces Round #243 (Div. 1)

---恢复内容开始--- A 枚举l,r 1 #include <iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include<algorithm> 5 #include<stdlib.h> 6 #include<vector> 7 #include<cmath> 8 #include<queue> 9 #include<set> 10 us

Codeforces Round #243 (Div. 1) A题

http://codeforces.com/contest/425/problem/A 题目链接: 然后拿出这道题目是很多人不会分析题目,被题目吓坏了,其中包括我自己,想出复杂度,一下就出了啊!真是弱! 直接暴力求出矩阵数值,然后枚举每一个[I,J];再O[N]判断,分配好在[I,J]区间的数和之内的数,再排序下SOLO了 CODE:#include <cstdio> #include <cstring>#include <queue>#include <vect

Codeforces Round #243 (Div. 2)——Sereja and Table

看这个问题之前,能够先看看这个论文<一类算法复合的方法>,说白了就是分类讨论,可是这个思想非常重要 题目链接 题意: 首先给出联通块的定义:对于相邻(上下和左右)的同样的数字视为一个联通块 现给一个n*m的仅仅有0和1的矩形和数字k,求出最小反转个数使得总体包含若干个矩形联通块(即每一个联通块均是矩形)(1?≤?n,?m?≤?100; 1?≤?k?≤?10) 假设最小次数比k大,输出-1 分析: 题目的特点是k比較小.也就是说反转的次数比較少,所以能够从这里入手.直接枚举全部的位置肯定是不行了

Codeforces Round #243 (Div. 1)——Sereja and Squares

题目链接 题意: 给n个点,求能组成的正方形的个数. 四边均平行与坐标轴 大神的分析: 经典题 我们考虑每一种x坐标,显然仅仅有<= sqrt{N}个x坐标出现了> sqrt{N}次,我们称这些为大的,其它为小的. 我们先考虑大的x和其它x之间的答案,先O(sqrt{N})枚举一个大的坐标,然后for其它的每一个点,这样能够依据x坐标的差算出正方形的边长,hash检查一下就能知道这个正方形是否存在. 之后考虑小的x和小的x之间的答案,注意到我们能够对每一个横坐标直接平方for,这样仅仅有(sq