Inna and Binary Logic

最新推荐文章于 2019-03-10 12:01:45 发布

_hehe_

最新推荐文章于 2019-03-10 12:01:45 发布

阅读量1.2k

点赞数 2

分类专栏：其他——思维训练数据结构文章标签： acm 思维训练 codeforces 二进制数据结构

本文链接：https://blog.csdn.net/wty__/article/details/20734305

版权

其他——思维训练同时被 2 个专栏收录

34 篇文章 0 订阅

订阅专栏

数据结构

7 篇文章 0 订阅

订阅专栏

这道题目考察了二进制逻辑操作。通过将数转化为0和1的排列，形成一个特殊的三角形结构。关键在于找到连续的1段来计算数值变化。在更新时，寻找不同之处，计算增加或减少的值。处理这类问题时，位操作转换为0、1操作有助于找到解题规律。注意在处理大数据结构时，使用引用以提高函数参数传递的效率。

摘要由CSDN通过智能技术生成

题目链接

题目大意：
给定n个数，相邻两个做与运算，可以得到一行新的数，一直重复下去会只剩最后一个数。然后输入a，b，把原来的a位置的数了、改成b，输出所有数的和

思路：
首先比较直观的方法是用二进制的思路，把每个数的每一位排列开，可以得到n个0、1的排列，然后按照上述规则可以形成一个上小下大的三角形。
观察下图可以发现，对于一个0（红色），可以把整体分成两个独立的三角形，那么可以想到，找到连续的1即可轻易算出这一段形成了几个1
然后在更新的时候，如果发现两个不一样，就需要找到这点左边第一个零和右边第一个零（找与修改点相邻的连续的‘1’段）计算出增加或减少的值

const int MAXN = 110000;
int num, kase;
int flag[22][MAXN];

LL fun()
{
    LL ret = 0;
    REP (index, 21)
    {
        LL cnt = 0, t = 0;
        FE(i, 1, num + 1)
        {
            if (flag[index][i] == 1)
                cnt++;
            else
            {
                t += ((cnt * cnt + cnt) >> 1);
                cnt = 0;
            }
        }
        ret += (1 << index) * t;
    }
    return ret;
}

void findlr(int* f, int n, int& l, int& r)
{
    int i = n - 1;
    while (f[i] == 1)
        i--;
    l = i + 1;

    i = n + 1;
    while (f[i] == 1)
        i++;
    r = i - 1;
}

int main()
{
//    freopen("in.txt", "r", stdin);
    int t, p;
    while (~RII(num, kase))
    {
        CLR(flag, 0);

        FE(i, 1, num)
        {
            RI(t);
            REP(ind, 21)
            {
                p = (1 << ind);
                flag[ind][i] = ((t & p) > 0);
            }
        }
        LL ans = fun();
        int a, b, l, r;
        REP(tt, kase)
        {
            RII(a, b);
            REP(ind, 21)
            {
                p = (1 << ind);
                if (((b & p) > 0) != flag[ind][a])
                {
                    findlr(flag[ind], a, l, r);
                    LL lenl = a - l, lenr = r - a;
                    ans += (1 - flag[ind][a] * 2) * p * (lenl * lenr + lenl + lenr + 1);
                    flag[ind][a] = !flag[ind][a];
                }
            }
            cout << ans << endl;
        }
    }
    return 0;
}

总结：
凡是涉及到位操作的，如^、&和|，都把原来的数分成单个位单独考虑，如此一来对数的操作（在位运算下是没有特点的，很难解题）就变成了对0,1的操作，就可以结合位运算的特点找到相应的规律来结题。

此处注意一下，在判断某一个点处相邻的连续‘1’段时，可以采用set来操作。详细见这篇文章

顺便说一下，在函数传递参数的时候，（下边的findlr函数，如果对大数据结构如数组、set、map等，一定要使用引用，要不会造成效率的很大下降）

const int MAXN = 110000;

template <class T>
T abs(T x)
{
    return x < 0 ? -x : x;
}

int num, kase;
int flag[22][MAXN];
set<int> st[22];
set<int>::iterator it;

LL fun()
{
    LL ret = 0;
    REP (index, 21)
    {
        LL cnt = 0, t = 0;
        FE(i, 1, num + 1)
        {
            if (flag[index][i] == 1)
                cnt++;
            else
            {
                t += ((cnt * cnt + cnt) >> 1);
                cnt = 0;
            }
        }
        ret += (1 << index) * t;
    }
    return ret;
}

void findlr(set<int>& s, int n, int& l, int& r)
{
    s.insert(n);
    it = s.find(n);
    it--;
    l = *it + 1;
    it++; it++;
    r = *s.lower_bound(n + 1) - 1;
}

int main()
{
//    freopen("in.txt", "r", stdin);
    int t, p;
    while (~RII(num, kase))
    {
        CLR(flag, 0);
        REP(i, 21)
        {
            FE(j, 0, num + 1)
                st[i].insert(j);
        }

        FE(i, 1, num)
        {
            RI(t);
            REP(ind, 21)
            {
                p = (1 << ind);
                if ((t & p) > 0)
                {
                    flag[ind][i] = 1;
                    st[ind].erase(i);
                }
                else
                    st[ind].insert(i);
            }
        }
        LL ans = fun();
        int a, b, l, r;
        REP(tt, kase)
        {
            RII(a, b);
            REP(ind, 21)
            {
                p = (1 << ind);
                if (((b & p) > 0) != flag[ind][a])
                {
                    findlr(st[ind], a, l, r);
                    LL lenl = a - l, lenr = r - a;
                    if (flag[ind][a] == 0)
                    {
                        st[ind].erase(a);
                        ans += p * (lenl * lenr + lenl + lenr + 1);
                    }
                    else
                    {
                        st[ind].insert(a);
                        ans -= p * (lenl * lenr + lenl + lenr + 1);
                    }
                    flag[ind][a] = !flag[ind][a];
                }
            }
            cout << ans << endl;
        }
    }
    return 0;
}