C++博客-From A Start,As An Acmer-随笔分类-乱搞

TC 538 DIV II 300+500

BUPT-[aswmtjdsj] @ Penalty — Wed, 21 Mar 2012 02:32:00 GMT

最近TC一路猛跌，现在光荣的在div2厮混。昨晚打了一场，全是ws题，可惜自己手速不够快，没抢到分也没cha够人。

300：
给你一个只包含LR?的序列，表示你每一步走的方向，？表示L、R都有可能，问你最远你能走多远（过程中）。

标准做法：贪心，枚举所有？为L或R。两遍扫。大略的证明，如果最远点在左边，那么过程中向右绝对没好处；反之亦然。
for i = 0 ,a = 0, i < len , i++
if s[i] = 'L' , a++
else a--
ans = max(abs(a),ans)

for i = 0 ,a = 0, i < len , i++
if s[i] = 'R' , a++
else a--
ans = max(abs(a),ans)

我的做法：由于本人经研究发现，自己贪心最弱，所以遇题从不敢写贪心，于是剪枝爆搜了一把。
O(2^(len/2))的搜索，亏着len <= 50
将原串中连续的L、R、？压缩成一个pair。LLL=pair(L,3)，塞到一个vector里面。
dfs之，遇到？pair的时候分化。
由于最坏情况为L?R?L?R?......所以最坏有25个离散的?，离散的LR不影响，因为不产生分支。
所以为O(2^25)的搜索。tc服务器比较快，俨然过了。

500：
没有发现水题本质哇，就是一个猜结论题。
你一开始在(0,0)，给你一个xy坐标序列，一个奇偶预测p。问你是否能找到一个走法序列使得你的步数满足这个预测。
举例：序列为(1,1),(1,0),p=1
则(0,0)-偶->(1,1)-奇->(1,0) ：奇，所以存在这样的序列。

结论：
咱们画个图表示一下：上层点代表偶点，下层点代表奇点。
奇解的情况：
________
\
--------------
偶解的情况：

________ __________
\ /
--------------

将序列的每个元素自加，奇就为奇点，偶就为偶点。
因为初始点为偶点，那么序列中存在的偶点有两个选择，要么缀在这个偶点之后，要么缀在之后的某个奇点之后。
假如存在奇点，那么也有两个选择，要么缀在偶点之后，要么插入偶点之间。
如果奇缀偶后为最终结果，那么该解为奇解。
如果奇插偶中为最终结果，那么该解为偶解。
那么显然，当序列中不存在偶点一定得不到偶解；不存在奇点则一定得不到奇解。

竟然想了半个小时，泪目。

BUPT-[aswmtjdsj] @ Penalty 2012-03-21 10:32 发表评论

sgu 108[卡内存什么的]

BUPT-[aswmtjdsj] @ Penalty — Fri, 16 Mar 2012 12:35:00 GMT

题目大意：
给一个n，另d(n)= n + sum{digit_i}(for i = 1 to length(n), digit_i is n's no.i digit)
若y = d(n)，则n就是y的generator。
若某个数没有generator，那么这个数就叫self number。
要求：给你一个N[1,10^7]，一个k[1,5000]
k个数，s1...sk。
让你求出[1,N]中有多少个self numbers。并输出k个a[si]，即第si个self number。保证si不大于N中self number的数量。

做法，本来很水的一题，用类似筛法的思想筛一遍就搞定了。
但是因为当年的SGU很穷，所以没钱买内存，于是乎内存只给了4M。必须用点ws的方法了。

10^7的bool数组大小约为9.5M，10^6的int数组约为4M内存（10^7中一共有977xxx个self numbers），省内存就要从两方面入手。

节省int数组的开销，即不存储这个数组，而是把输入的si排序，当扫描到对应的si的时候，直接标记下来。注意wa点：si不一定有序，且有可能重复。
节省bool数组的开销：
法1：位压缩，bitset或者手写位运算均可。
法2：滚动数组。由于d(n) <= n + 9*7在10^7的范围内。所以只需开一个64大小的滚动数组即可。
实现：
if(vis[i%64])//if(vis[i&63])
{
//blabla
}
vis[i%64] = true;//这时候i已经扫描过去了，所以对于下一个等于i%64的i，默认是true的
vis[d(i)%64] = false;//筛掉d(i)

虽然我莫名其妙的G++WA on testcase9，C++AC了吧。。

各种小技巧还是挺有意思的。

BUPT-[aswmtjdsj] @ Penalty 2012-03-16 20:35 发表评论

HDU 4022 Bombing【STL 继续练习】

BUPT-[aswmtjdsj] @ Penalty — Sat, 10 Sep 2011 11:10:00 GMT

今天真是各种sb，弱爆了。
果然以后做网预的时候就应该第一道水题用STL各种水。
闲话少说。
本题题意略，直接说做法。
首先，必需的是离散化。sort+MAP是我的离散化方法，个人觉得这样虽然慢，但是好写。
后面的就八仙过海各显神通了。什么用十字链表模拟啊，什么multiset啊，什么vector啊，什么数组直接标记啊，不一而足，水题就要用水题的方法做。
我是vector做的。
开了200000个vector分别用来存储离散化后的每行及每列中元素的个数。
每次查询的时候，将对应行/或者列的size输出，然后对其中每个元素在另外一边（行/列）用upper/lower_bound查存在性，存在的都删除erase，然后将本行/列清空clear。
一开始就是WA在此处了，因为有重复坐标的点，而set的一般写法无法处理这种情况，想了半天最后用了vector+二分。太蛋疼了。
还RE了一次，因为对于vector来说，erase作为动态删除会使其周围元素的指针改变，会发生内存泄漏、指针悬挂等现象，所以果断要用erase的范围删除操作[low,up)。
没啥说的，复杂度均摊下来很小，因为不会重复统计，所以顶多是NlogN的复杂度，再加上离散化的复杂度，整体NlogN。

老话，STL能做，为啥要手写？出题卡STL的就是sb，不解释；至于什么叫卡STL，各位大牛都懂得。
今天弱爆了，就这样吧。
附代码：

#include <iostream>
#include <cstdio>
#include <set>
#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 100005
struct point
{
    int x,y;
    point(){}
    point(int a,int b):x(a),y(b){}
}p[maxn];
int x[maxn],y[maxn];
int n,m;
vector <int> X[maxn],Y[maxn];
map <int,int> MX,MY;
vector <int> ::iterator xlow,xup,ylow,yup,idx,idy;
int main()
{
    while(scanf("%d %d",&n,&m) == 2 && (n || m))
    {
        MX.clear();
        MY.clear();
        for(int i = 1;i <= n;i++)
        {
            if(!X[i].empty())
                X[i].clear();
            if(!Y[i].empty())
                Y[i].clear();
        }
        for(int i = 0;i < n;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            p[i] = point(a,b);
            x[i] = a;
            y[i] = b;
        }
        sort(x,x + n);
        sort(y,y + n);
        int cntx = 1,cnty = 1;
        for(int i = 0;i < n;i++)
        {
            if(MX[x[i]] == 0)
                MX[x[i]] = cntx++;
            if(MY[y[i]] == 0)
                MY[y[i]] = cnty++;
        }
        for(int i = 0;i < n;i++)
        {
            p[i].x = MX[p[i].x];
            p[i].y = MY[p[i].y];
            idx = lower_bound(X[p[i].x].begin(),X[p[i].x].end(),p[i].y);
            X[p[i].x].insert(idx,p[i].y);
            idy = lower_bound(Y[p[i].y].begin(),Y[p[i].y].end(),p[i].x);
            Y[p[i].y].insert(idy,p[i].x);
        }
        for(int i = 0;i < m;i++)
        {
            int mod,d;
            scanf("%d %d",&mod,&d);
            if(mod == 0)
            {
                d = MX[d];
                printf("%d\n",X[d].size());
                if(X[d].empty())
                    continue;
                for(idx = X[d].begin();idx != X[d].end();idx++)
                {
                    int p = *idx;
                    ylow = lower_bound(Y[p].begin(),Y[p].end(),d);
                    yup = upper_bound(Y[p].begin(),Y[p].end(),d);
                    Y[p].erase(ylow,yup);
                }
                X[d].clear();
            }
            else
            {
                d = MY[d];
                printf("%d\n",Y[d].size());
                if(Y[d].empty())
                    continue;
                for(idy = Y[d].begin();idy != Y[d].end();idy++)
                {
                    int p = *idy;
                    xlow = lower_bound(X[p].begin(),X[p].end(),d);
                    xup = upper_bound(X[p].begin(),X[p].end(),d);
                    X[p].erase(xlow,xup);
                }
                Y[d].clear();
            }
        }
        puts("");
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-10 19:10 发表评论

HDU 3972 1M Possible 【乱搞】

BUPT-[aswmtjdsj] @ Penalty — Thu, 25 Aug 2011 11:47:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=3972
这种题算是脑筋急转弯题吧- -，一切都是珂神的大脑- -

先说一道这类型题目的入门题。
给你3n+1个数，让你找出多出来的那个数（其他是n个等价三元组）。
鉴于三元组的“三”和卡内存什么的。。。所以按二进制位搞之吧。。
把读入的数字按二进制展开，存到一个[32]的数组里面，如果某位为1则对应元素++。
然后把这个数组中的每个元素的值都模3。把这个数组的元素按二进制数还原回一个整数，还原的时候某元素非0则对应为1。
这个数就是所求。

再看这题，是多出来两个数，那么按照上面的方法做，把最后一步改一下，还原二进制数的时候就按照对应元素来还原（而非1/0），那么还原来的数字是什么呢？
假设最后剩下的数字是a和b，那么还原回来的数字就是X=a+b。因为加法的本质就是按位加。
那只有“和”是求不出来解的啊少年。
于是珂神想出了一种方法，就是再次记录这些数字，但通过不同的形式，让其表现的不同，从而建立一个二元关系方程组来求解。
把读入的每个数都平方，再按照上面的方法统计在一个[64]的数组里面（因为会long long）。
最后还原回来的数字就是Y=a^2+b^2。
然后联立解方程即可。
恶心的地方在于因为出现的最大数字为2^31-1，所以中间处理精度和算数上溢的时候要无比小心。
因为中间出现了a+b，所以还原的数字要用unsigned int存。
因为中间出现了a^2+b^2而且解方程的时候中间值有它的2倍，所以还原的数字要用unsigned long long 存。
然后另一个问题就是位移操作的操作数要注意，结果为long long或者为unsigned long long的位移，左操作数要为对应类型，即1ll或者1llu。
解方程的时候亏着没被精度卡掉，太感动了。
注意输出顺序和delta=0的时候。
附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
int small[65],big[65];
typedef unsigned long long ull;
const ull whatfuck = 1;
void gao()
{
    int n;
    scanf("%d",&n);
    memset(small,0,sizeof(small));
    memset(big,0,sizeof(big));
    for(int i = 0;i < n;i++)
    {
        int opt;
        ull num;
        scanf("%d",&opt);
        num = (ull)opt * (ull)opt;
        for(int j = 0;j < 31;j++)
        {
            small[j] += ((opt >> j) & whatfuck);
            small[j] %= 3;
        }
        for(int j = 0;j < 63;j++)
        {
            big[j] += ((num >> j) & whatfuck);
            big[j] %= 3;
        }
    }
    ull SMALL = 0;
    ull BIG = 0;
    for(int i = 0;i < 31;i++)
        if(small[i])
            SMALL += (ull)small[i] * (whatfuck << i);
    for(int i = 0;i < 63;i++)
        if(big[i])
            BIG += (ull)big[i] * (whatfuck << i);
    double det = 2 * BIG - SMALL * SMALL;
    int fuck1,fuck2;
    double x1 = 0.5 * (SMALL + sqrt(det)),x2 = 0.5 * (SMALL - sqrt(det));
    fuck1 = min(x1,x2),fuck2 = max(x1,x2);
    printf("%d %d\n",fuck1,fuck2);
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)
        gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-25 19:47 发表评论