国产V亚洲V天堂无码久久久 ,亚洲精品无码久久久久久,久久国产香蕉视频

poj 3264 Balanced Lineup St��法建立Rmq

yx — Thu, 25 Oct 2012 11:29:00 GMT

ST��法可以说就是个二维的动态规划，黑书上有解释�?br />

#include
#include <string.h>
#include
#include
using namespace std;

const int MAX_I = 50010;
const int MAX_J = 20;

int nMax[MAX_I][MAX_J];
int nMin[MAX_I][MAX_J];
int nArr[MAX_I];
int nN, nQ;

void InitRmq(int nN)
{
    for (int i = 1; i <= nN; ++i)
    {
        nMax[i][0] = nMin[i][0] = nArr[i];
    }

    for (int j = 1; (1 << j) <= nN; ++j)
    {
        for (int i = 1; i + (1 << j) - 1 <= nN; ++i)
        {
            nMax[i][j] = max(nMax[i][j - 1],
                             nMax[i + (1 << (j - 1))][j - 1]);
            nMin[i][j] = min(nMin[i][j - 1],
                             nMin[i + (1 << (j - 1))][j - 1]);
        }
    }
}

int Query(int nA, int nB)
{
    int k = (int)(log(1.0 * nB - nA + 1) / log(2.0));
    int nBig = max(nMax[nA][k], nMax[nB - (1 << k) + 1][k]);
    int nSml = min(nMin[nA][k], nMin[nB - (1 << k) + 1][k]);
    return nBig - nSml;
}

int main()
{
    while (scanf("%d%d", &nN, &nQ) == 2)
    {
        for (int i = 1; i <= nN; ++i)
        {
            scanf("%d", &nArr[i]);
        }
        InitRmq(nN);
        for (int i = 0; i < nQ; ++i)
        {
            int nA, nB;
            scanf("%d%d", &nA, &nB);
            printf("%d\n", Query(nA, nB));
        }
    }

    return 0;
}

yx 2012-10-25 19:29 发表评论

poj 3764 The xor-longest Path 字典�?+ Xor

yx — Fri, 12 Oct 2012 12:12:00 GMT

�q�题意思很��单。求一��|��里面的一条�\径，使得其异或权(��是��\径里面所有边的权值异
或�v�?最大�?br /> �q�个题有两步。第一步是假定根�ؓ节点0�Q�求出根到其它节点的异或距离�Q�保存在数组xor里面�Q?br />�q�个dfs一下即可。然后，用xor[i]^xor[j]��p��代表节点i到节点j的�\径。这个结论可以这么看�?br />如果�Q�i和j之间的�\径经�q�根节点�Q�那么上面的�l�论肯定是正��的。如果，该�\径不�l�过根，那么
xor[i]和xor[j]必定保护从根到某个节点的相同的一�D�子路径�Q�根据异或的性质�Q�这�D�子路径�?br />被消掉，所以这个结��Z��是这��的。。�?br /> �W�二步就是枚举，xor[i]^xor[j]使得�l�果最大了。如果直接暴力，�q�x��的算法肯定会��时的�?br />�׃��每个值可以表�C�成2�q�制�Q�如果把其它xor值都保存在字典树里面�Q�用当前的xor[i]��d��典树
里面�Q�一遍就可以扑ֈ�异或最大倹{�?br /> 另外�Q�由于树的点数太多，只能用邻接表�Q�用vector模拟��L��表果断超时了。。�?br />�Ҏ(gu��)��静态链表才�q�。。�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
#include
using namespace std;

const int MAX = 100010;
int nXor[MAX];
bool bVis[MAX];
int nFirst[MAX];
struct Edge
{
    int nE;
    int nW;
    int nNext;
};
Edge egs[MAX * 2];

struct Node
{
    Node* pSons[2];
};
Node nodes[MAX * 32];
Node* pRoot = &nodes[0];
int nNew;

void GetBCode(int nL, int* nBCode, int& nLen)
{
    nLen = 0;
    while (nLen <= 30)
    {
        nBCode[nLen++] = nL % 2;
        nL >>= 1;
    }
    reverse(nBCode, nBCode + nLen);
}

void Insert(int nL)
{
    int nLen = 0;
    int i = 0;
    int nBCode[32];

    GetBCode(nL, nBCode, nLen);
    Node* pNode = pRoot;

    while (i < nLen)
    {
        if (pNode->pSons[nBCode[i]])
        {
            pNode = pNode->pSons[nBCode[i]];
        }
        else
        {
            memset(nodes + nNew, 0, sizeof(nodes[nNew]));
            pNode->pSons[nBCode[i]] = nodes + nNew;
            pNode = nodes + nNew;
            ++nNew;
        }
        ++i;
    }
}

int FindMax(int nL)
{
    int nLen = 0;
    int nAns = 0;
    int i = 0;
    int nBCode[32];
    Node* pNode = pRoot;

    GetBCode(nL, nBCode, nLen);
    while (i < nLen)
    {
        int nBest = (nBCode[i] == 0 ? 1 : 0);
        int nBad = (nBCode[i] == 0 ? 0 : 1);
        if (pNode->pSons[nBest])
        {
            nAns = 2 * nAns + nBest;
            pNode = pNode->pSons[nBest];
        }
        else if (pNode->pSons[nBad])
        {
            nAns = 2 * nAns + nBad;
            pNode = pNode->pSons[nBad];
        }
        else break;
        ++i;
    }

    return nAns ^ nL;
}

void Dfs(int nV, int nL)
{
    nXor[nV] = nL;
    bVis[nV] = true;
    for (int e = nFirst[nV]; e != -1; e = egs[e].nNext)
    {
        if (!bVis[egs[e].nE])
        {
            Dfs(egs[e].nE, nL ^ egs[e].nW);
        }
    }
}

int main()
{
    int nN;
    int nU, nV, nW;

    while (scanf("%d", &nN) == 1)
    {
        for (int i = 0; i < nN; ++i) nFirst[i] = -1;
        for (int i = 1, j = 0; i < nN; ++i)
        {
            scanf("%d%d%d", &nU, &nV, &nW);
            egs[j].nE = nV;
            egs[j].nW = nW;
            egs[j].nNext = nFirst[nU];
            nFirst[nU] = j++;
            egs[j].nE = nU;
            egs[j].nW = nW;
            egs[j].nNext = nFirst[nV];
            nFirst[nV] = j++;
        }

        memset(bVis, false, sizeof(bool) * nN);
        Dfs(0, 0);

        memset(&nodes[0], 0, sizeof(Node));
        nNew = 1;
        int nAns = 0;

        for (int i = 0; i < nN; ++i)
        {
            nAns = max(nAns, FindMax(nXor[i]));
            Insert(nXor[i]);
        }
        printf("%d\n", nAns);
    }

    return 0;
}

yx 2012-10-12 20:12 发表评论

yx — Wed, 10 Oct 2012 12:51:00 GMT

�q�是�q�查集最后一题，据说也是最�l�典的一题。经常前面几题的训练�Q�这题的思�\很快
��p��惛_��来了。只需要对每个节点附加一个信息表�C�离根节点的距离�Q��ƈ且距��L��?循环的�?br /> 注意合�ƈ时候保持距��d��化的正确性。而且合�ƈ�?�U�情况，距离相同合�ƈ和距��M��同合�q��?br />分别对应于题目描�q�C��?�?操作�?br /> 关键�q�是FindSet里面对距��nDis数组里面的修改，前面一直写错这个，wa了好几次�Q�还�?br />看队友代码才一眼发现我又把�q�里写错了。。。当前距��ȝ��更新�q�是�{�于当前距离加上前一�?br />节点的距��d��?�Q�类��g��前面几题的更新方法�?br /> �q�种��有关系的节�Ҏ(gu��)��在一个�ƈ查集里面�Q�再�l�每个节炚w��加其它信息描�q�其它关�pȝ��做法�Q?br />��实比较有效。。。�ƈ查集是应用于不相交集合的数据�l�构�Q�看来某个时候却有妙用啊。。�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
using namespace std;

const int MAX = 50010;
int nN, nK;
int nSets[MAX];
int nDis[MAX];

void MakeSets(int nN)
{
    for (int i = 1; i <= nN; ++i)
    {
        nSets[i] = i;
        nDis[i] = 0;
    }
}

int FindSet(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSet(nSets[nI]);
        nDis[nI] = (nDis[nPre] + nDis[nI]) % 3;
    }
    return nSets[nI];
}

int main()
{
    int nAns = 0;
    int nOper, nX, nY;

    scanf("%d%d", &nN, &nK);
    MakeSets(nN);
    while (nK--)
    {
        scanf("%d%d%d", &nOper, &nX, &nY);
        if (nX > nN || nY > nN || nOper == 2 && nX == nY)
        {
            ++nAns;
        }
        else
        {
            if (nOper == 1)
            {
                int nA = FindSet(nX);
                int nB = FindSet(nY);
                if (nA == nB)
                {
                    if (nDis[nX] != nDis[nY])
                    {
                        ++nAns;
                    }
                }
                else
                {
                    nSets[nB] = nA;
                    nDis[nB] = (nDis[nX] - nDis[nY] + 3) % 3;
                }
            }
            else
            {
                int nA = FindSet(nX);
                int nB = FindSet(nY);
                if (nA == nB)
                {
                    if ((nDis[nX] + 1) % 3 != nDis[nY])
                    {
                        ++nAns;
                    }
                }
                else
                {
                    nSets[nB] = nA;
                    nDis[nB] = (nDis[nX] + 1 - nDis[nY] + 3) % 3;
                }
            }
        }
    }
    printf("%d\n", nAns);

    return 0;
}

yx 2012-10-10 20:51 发表评论

yx — Wed, 10 Oct 2012 04:15:00 GMT

也是个题意比较奇葩的题目。有2个操作，1个是把一个元素所在的栈，攑ֈ�另外1个元素所�?br />的栈上面。另外一个操作是�l�计某个元素下面有多��个元素(当然是在同一个栈中）�?br /> 貌似�Q�需要记录每个元素下面的元素是什么了�Q�既然要记录�q�个��׃��能用�q�查集的路径压羃了�?br /> 不压�~��\径的话，肯定会超时的。怎么办了。。�?br /> 其实�Q�可以这么考虑�Q�以每个栈的栈底元素作�ؓ�q�查集的代表元素。压�~��\径后�Q�每个元素或�?br />是根元素或者其父亲元素��是根元素。所以，另外�Ҏ(gu��)��个节炚w��加个信息代表该节点的高度�Q�栈�?br />元素高度�?。再附加个信息代表每个�ƈ查集元素��L��目，�q�样��可以在合�ƈ集合时候修改信息，
�q�且压羃路径也能保证�{�案正确。。�?br />
代码如下�Q?br />

#include
#include
#include <string.h>
#include
using namespace std;

const int MAX = 30010;
int nSets[MAX];
int nNum[MAX];
int nRank[MAX];

void MakeSets(int nN)
{
    for (int i = 0; i < nN; ++i)
    {
        nSets[i] = i;
        nNum[i] = 1;
        nRank[i] = 0;
    }
}

int FindSet(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSet(nSets[nI]);
        nRank[nI] += nRank[nPre];
    }

    return nSets[nI];
}

void Move(int nX, int nY)
{
    int nA = FindSet(nX);
    int nB = FindSet(nY);
    //printf("nA:%d,nB:%d\n", nA, nB);
    if (nA != nB)
    {
        nSets[nA] = nB;
        nRank[nA] += nNum[nB];
        nNum[nB] += nNum[nA];
    }
}

int main()
{
    int nP;
    char szOper[10];
    int nX, nY;

    scanf("%d", &nP);
    MakeSets(MAX);
    while (nP--)
    {
        scanf("%s", szOper);
        if (szOper[0] == 'M')
        {
            scanf("%d%d", &nX, &nY);
            Move(nX, nY);
        }
        else
        {
            scanf("%d", &nX);
            FindSet(nX);
            printf("%d\n", nRank[nX]);
        }
    }

    return 0;
}

yx 2012-10-10 12:15 发表评论

yx — Tue, 09 Oct 2012 13:25:00 GMT

�q�查集应用的变�Ş。题目意思是一个图中，只有上下左右四个方向的边。给��L��一些边�Q?br />求�Q意指定的2个节点之间的距离�?br /> 有可能当前给出的信息�Q�没有涉及到要求�?个节点，或者只涉及��C��1个节点，那么肯定
无法��定它们的距��R��或者根据已�l�给出的边只知道�q?个节点在不同的联通分量里面，那么�?br />距离也是无法��定的，�Ҏ(gu��)��题目要求�Q�输�?1�?br /> 问题是如果能够确定它们在一个联通分量里面，如何��定它们的距��M��?br /> �q�个题的关键在于�Q�只有上下左叛_��个方向的边，假设每个节点都有一个坐标的话，那么它们
相对于代表该联通分量节点的坐标肯定是固定的�Q�那么就不需要考虑��N��面有环之�cȝ��情况了�?br />�q�样��可以很方便的应用�ƈ查集来解了�?br /> 利用�q�查集，�l�每个节炚w��加其它信息，即相对于代表该�ƈ查集的节点的坐标�Q�x�Q�y�Q��?br />在FindSet里面求出坐标�Q�在UnionSet里面修改合�ƈ后新加入的另外一个集合的根节点的坐标卛_��?br /> 代码如下�Q?br />

#include
#include <string.h>
#include
#include
using namespace std;

const int MAX_N = 40010;
int nN, nM;
int nSets[MAX_N];
int nX[MAX_N];
int nY[MAX_N];
char szInput[MAX_N][100];

void MakeSets(int nNum)
{
    for (int i = 0; i < nNum; ++i)
    {
        nSets[i] = i;
        nX[i] = nY[i] = 0;
    }
}

int FindSets(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSets(nSets[nI]);
        nX[nI] += nX[nPre];
        nY[nI] += nY[nPre];
    }
    return nSets[nI];
}

void UnionSets(int nBeg, int nEnd, int dx, int dy)
{
    int nA = FindSets(nBeg);
    int nB = FindSets(nEnd);
    if (nA != nB)
    {
        nSets[nB] = nA;//把集合B合�ƈ到集合A�?/span>
        nX[nB] = nX[nBeg] + dx - nX[nEnd];//因�ؓ方向逆过来了,所以是减去
        nY[nB] = nY[nBeg] + dy - nY[nEnd];
    }
}

int main()
{
    int nBeg, nEnd, nL;
    char szDir[10];

    while (scanf("%d%d%*c", &nN, &nM) == 2)
    {
        MakeSets(nN);
        for (int i = 0; i < nM; ++i)
        {
            fgets(szInput[i], 100, stdin);
        }
        int nK;
        int nF1, nF2, nI;
        scanf("%d", &nK);
        int nCur = 0;
        while (nK--)
        {
            scanf("%d%d%d", &nF1, &nF2, &nI);
            for (int i = nCur; i < nI; ++i)
            {
                sscanf(szInput[i], "%d%d%d%s", &nBeg,
                       &nEnd, &nL, szDir);
                int dx = 0, dy = 0;
                switch (szDir[0])
                {
                    case 'N': dy += nL; break;
                    case 'S': dy -= nL; break;
                    case 'E': dx += nL; break;
                    case 'W': dx -= nL; break;
                }
                UnionSets(nBeg, nEnd, dx, dy);
            }
            nCur = nI;

            if (FindSets(nF1) != FindSets(nF2))
            {
                printf("-1\n");
            }
            else
            {
                printf("%d\n", abs(nX[nF1] - nX[nF2])
                        + abs(nY[nF1] - nY[nF2]));
            }
        }
    }

    return 0;
}

yx 2012-10-09 21:25 发表评论

yx — Mon, 08 Oct 2012 14:33:00 GMT

�q�查集应用的变�Ş�?br /> �l�出的是2个节�Ҏ(gu��)��敌对关系的信息，最后询问�Q�?个节点的关系。根据这些信息，
节点之间可能是敌对的�Q�也可能不是的（因�ؓ敌�h的敌人就是朋友）�Q�也可能�l�出�?br />信息�Ҏ(gu��)��描述不了它们的关�p�R�?br /> 看�v来跟原始的�ƈ查集应用差远了。。�?br /> 有个比较直接的做法，那么��是把不在一个集合的节点直接用�ƈ查集合�ƈ在一赗��这��L��话，
如果询问�?个节点在同一个�ƈ查集里面�Q�那么它们之间的关系是确定的�Q�否则无法确定它们的
关系�?br /> 现在�q�有一个问题是�Q�在同一个�ƈ查集里面�?个节�Ҏ(gu��)��敌对关系�q�是朋友关系。。�?br /> 可以�l�每个节点另外附加个信息�Q�记录其距离�q�查集根节点的距��R��如果，询问�?个节点距��?br />其根节点的距��都是奇数或者都是偶敎ͼ�那么�q?个节�Ҏ(gu��)��朋友关系�Q�否则是敌对关系。。�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
using namespace std;

const int MAX_N = 100010;
int nSets[MAX_N];
int nDis[MAX_N];

int nN, nM;

void MakeSets(int nNum)
{
    for (int i = 0; i < nNum; ++i)
    {
        nSets[i] = i;
        nDis[i] = 0;
    }
}

int FindSet(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSet(nSets[nI]);
        nDis[nI] = (nDis[nI] + nDis[nPre]) % 2;
    }
    return nSets[nI];
}

void UnionSet(int nI, int nJ)
{
    int nA = FindSet(nI);
    int nB = FindSet(nJ);
    if (nA != nB)
    {
        nSets[nA] = nB;
        nDis[nA] = (nDis[nI] + nDis[nJ] + 1) % 2;
    }
}

int main()
{
    int nT;

    scanf("%d", &nT);
    while (nT--)
    {
        scanf("%d%d", &nN, &nM);
        MakeSets(nN);
        char szOper[10];
        int nA, nB;
        while (nM--)
        {
            scanf("%s%d%d", szOper, &nA, &nB);
            if (szOper[0] == 'D')
            {
                UnionSet(nA, nB);
            }
            else
            {
                int nX = FindSet(nA);
                int nY = FindSet(nB);
                if (nX == nY)
                {
                    if (nDis[nA] == nDis[nB])
                    {
                        printf("In the same gang.\n");
                    }
                    else
                    {
                        printf("In different gangs.\n");
                    }
                }
                else
                {
                    printf("Not sure yet.\n");
                }
            }
        }
    }

    return 0;
}

yx 2012-10-08 22:33 发表评论

yx — Sun, 16 Sep 2012 12:42:00 GMT

用线�D�|��成段更新不能立即全部更新�Q�必��L��延迟操作。其实，��是针对每个节点�Q�另外搞一个域表示延迟
更新的数目。然后，在更新操作和查找操作的时候都把父亲节点的延迟域往2个儿子走�?br /> �q�个题是要成�D�增加��|��所以在写PushDown函数的时候要注意�Q�只能给儿子节点加上父亲节点压过来的�?br />乘以儿子区间的长度。这题貌似用树状数组也可以做�Q�不�q�解法肯定意思不是那么直白的。不�q�速度肯定会快�?br />树状数组解法�Q?a >http://kenby.iteye.com/blog/962159
�U�段树网上流行的解法都是开最多节�Ҏ(gu��)��?倍的数组。以位置1作�ؓ根，每个位置其实代表的是一个区间�?br />某�h位置1代表1-N或�?-(N-1)区间�Q�具体看题目了。那�?��׃��表区�?-(1+N)/2�Q?��׃��表区�?1+N)/2+1 - N了�?br /> 至于lazy标记�q�是搞个大数�l�，意义和线�D�|��数组一��P��搞清楚之后写��h��都比较简单，最重要的是变�Ş�?br />解决一些要求奇怪的题目�?br />

#include

#include <string.h>
#include
using namespace std;
typedef long long INT;

const INT MAX_N = 100010;
const INT INF = 0x7ffffffffffffffLL;
INT nTree[MAX_N << 2];
INT nAdd[MAX_N << 2];
INT nN, nQ;

void PushUp(INT nRt)
{
    nTree[nRt] = nTree[nRt << 1] + nTree[nRt << 1 | 1];
}

void BuildTree(INT nL, INT nR, INT nRt)
{
    nAdd[nRt] = 0;
    if (nL == nR)
    {
        scanf("%I64d", &nTree[nRt]);
        return;
    }

    INT nMid = (nL + nR) >> 1;
    BuildTree(nL, nMid, nRt << 1);
    BuildTree(nMid + 1, nR, nRt << 1 | 1);
    PushUp(nRt);
}

void PushDown(INT nL, INT nR, INT nRt)
{
    INT nMid = (nL + nR) >> 1;
    INT nLs = nRt << 1;
    INT nRs = nLs | 1;

    if (nAdd[nRt])
    {
        nAdd[nLs] += nAdd[nRt];
        nAdd[nRs] += nAdd[nRt];
        nTree[nLs] += (nMid - nL + 1) * nAdd[nRt];
        nTree[nRs] += (nR - nMid) * nAdd[nRt];
        nAdd[nRt] = 0;
    }
}

void Update(INT nL, INT nR, INT nRt, INT nX, INT nY, INT nV)
{
    if (nL >= nX && nR <= nY)
    {
        nTree[nRt] += nV * (nR - nL + 1);
        nAdd[nRt] += nV;
        return;
    }

    PushDown(nL, nR, nRt);
    INT nMid = (nL + nR) >> 1;
    if (nX <= nMid) Update(nL, nMid, nRt << 1, nX, nY, nV);
    if (nY > nMid) Update(nMid + 1, nR, nRt << 1 | 1, nX, nY, nV);
    PushUp(nRt);
}

INT Query(INT nL, INT nR, INT nRt, INT nX, INT nY)
{
    if (nL >= nX && nR <= nY)
    {
        return nTree[nRt];
    }
    PushDown(nL, nR, nRt);
    INT nAns = 0;
    INT nMid = (nL + nR) >> 1;
    if (nX <= nMid) nAns += Query(nL, nMid, nRt << 1, nX, nY);
    if (nY > nMid) nAns += Query(nMid + 1, nR, nRt << 1 | 1, nX, nY);
    return nAns;
}

int main()
{
    INT nTemp;
    while (scanf("%I64d%I64d", &nN, &nQ) == 2)
    {
        BuildTree(1, nN, 1);

        while (nQ--)
        {
            char szCmd[10];
            INT nX, nY, nV;
            scanf("%s", szCmd);
            if (szCmd[0] == 'Q')
            {
                scanf("%I64d%I64d", &nX, &nY);
                printf("%I64d\n", Query(1, nN, 1, nX, nY));
            }
            else
            {
                scanf("%I64d%I64d%I64d", &nX, &nY, &nV);
                Update(1, nN, 1, nX, nY, nV);
            }
        }
    }

    return 0;
}

yx 2012-09-16 20:42 发表评论

poj 2886 Who Gets the Most Candies? �U�瑟夫环和反素数

yx — Fri, 14 Sep 2012 12:53:00 GMT

直接模拟�U�瑟夫环是N^2�Q�况且这题每�ơ移动的距离和方向都是不��定的，只能模拟�Q�如果加快查扑֒��U�d��的话�Q?br />可以提高速度�Q�果断用�U�段树维护当前位�|�前面有多少个�h�?br /> 至于反素数指的是求一个小于等于N的数字，使得其因子个数在1-N中是最大的。这个利用一个必要条件暴力搜索即可�?br />

其实��是利用下面�q?个性质搜烦的�?br /> 性质一:一个反素数的质因子必然是从2开始连�l�的质数�?/span>性质�?p=2^t1*3^t2*5^t3*7^t4.....必然t1>=t2>=t3>=....�?br />
代码如下�Q?br />

#include
#include <string.h>
#include
#include
using namespace std;

int nPrime[16] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};
int nAns;
int nCN;
const int MAX_N = 500010;
//nPow不会��过20
void InitBest(int nCur, int nI, int nMax, int nN, int nNum)
{
    if (nCur > nN) return;
    if (nNum > nCN){nAns = nCur;nCN = nNum;}
    if (nNum == nCN){nAns = min(nAns, nCur);}
    for (int i = 1; i <= nMax; ++i)
    {
        nCur *= nPrime[nI];
        if (nCur > nN)return;//不加�q�句优化会超�?/span>
        if (nI < 15)
        InitBest(nCur, nI + 1, i, nN, nNum * (i + 1));
    }
}

char szNames[MAX_N][10];
int nValue[MAX_N];
int nTree[MAX_N << 2];
void PushUp(int nRt)
{
    nTree[nRt] = nTree[nRt << 1] + nTree[nRt << 1 | 1];
}

void BuildTree(int nL, int nR, int nRt, int nV)
{
    if (nL == nR)
    {
        nTree[nRt] = nV;
        return;
    }
    int nMid = (nL + nR) >> 1;
    BuildTree(nL, nMid, nRt << 1, nV);
    BuildTree(nMid + 1, nR, nRt << 1 | 1, nV);
    PushUp(nRt);
}

void Add(int nL, int nR, int nRt, int nP, int nV)
{
    if (nL == nR)
    {
        nTree[nRt] += nV;
    }
    else
    {
        int nMid = (nL + nR) >> 1;
        if (nP <= nMid)Add(nL, nMid, nRt << 1, nP, nV);
        else Add(nMid + 1, nR, nRt << 1 | 1, nP, nV);
        PushUp(nRt);
    }
}

int Query(int nL, int nR, int nRt, int nSum)
{
    if (nL == nR)
    {
        return nL;
    }
    int nMid = (nL + nR) >> 1;
    int nLs = nRt << 1;
    int nRs = nLs | 1;
    if (nTree[nLs] >= nSum) return Query(nL, nMid, nLs, nSum);
    else return Query(nMid + 1, nR, nRs, nSum - nTree[nLs]);
}

int main()
{
    //InitBest(1, 0, 15);
    int nN, nK;

    while (scanf("%d%d", &nN, &nK) == 2)
    {
        nK--;
        nAns = 2;
        nCN = 0;
        InitBest(1, 0, 20, nN, 1);
        //printf("ans:%d cn:%d\n", nAns, nCN);
        for (int i = 0; i < nN; ++i)
        {
            scanf("%s%d", szNames[i], &nValue[i]);
        }

        BuildTree(0, nN - 1, 1, 1);
        int nTotal = nN;
        int nPos;
        for (int i = 0; i < nAns; ++i)
        {
            nPos = Query(0, nN - 1, 1, nK + 1);
            //printf("nK:%d %s %d\n", nK, szNames[nPos], nValue[nPos]);
            nTotal--;
            Add(0, nN - 1, 1, nPos, -1);
            if (!nTotal)break;
            if (nValue[nPos] >= 0)
            {
                nK = (nK - 1 + nValue[nPos] + nTotal) % nTotal;
            }
            else
            {
                nK = ((nK + nValue[nPos]) % nTotal + nTotal) % nTotal;
            }
        }
        printf("%s %d\n", szNames[nPos], nCN);
    }

    return 0;
}

yx 2012-09-14 20:53 发表评论

hdu 2492 Ping pong 树状数组

yx — Wed, 12 Sep 2012 13:11:00 GMT

此题是求一个数字序列中�Q�长度�ؓ3的子序列(a,b,c)�Q�且满��条�ga<=b<=c或者c<=b<=a的子序列的个数�?br /> 明显枚�D每个b�Q�求每个b左边的a的个数和双��c的个敎ͼ�以及左边c的个数和双��a的个敎ͼ�然后累加左右乘积求和卛_��?br /> 刚开始只求了满��条�ga<=b<=c的部分，而且忘记�?4位了。wa了几�ơ。求左边a的个数其实就是求��于�{�于b的数�?br />的个敎ͼ��q�个刚好可以用树状数�l�或者线�D�|��求。具体见代码�?br />
代码如下�Q?br />

#include

#include <string.h>
#include
using namespace std;
typedef long long INT;
const INT MAX_N =  100010;
const INT N = 20010;
INT nN;
INT nNum[N];
INT nTree[MAX_N + 10];
INT nLeft[2][N], nRight[2][N];

INT LowBit(INT nI)
{
    return nI & (-nI);
}

void Add(INT nI, INT nAdd)
{
    while (nI <= MAX_N)
    {
        nTree[nI] += nAdd;
        nI += LowBit(nI);
    }
}

INT Query(INT nPos)
{
    INT nAns = 0;
    while (nPos > 0)
    {
        nAns += nTree[nPos];
        nPos -= LowBit(nPos);
    }
    return nAns;
}

int main()
{
    INT nT;

    scanf("%I64d", &nT);
    while (nT--)
    {
        scanf("%I64d", &nN);
        memset(nTree, 0, sizeof(nTree));
        for (INT i = 1; i <= nN; ++i)
        {
            scanf("%I64d", &nNum[i]);
            nLeft[0][i] = Query(nNum[i]);
            nLeft[1][i] = Query(MAX_N) - Query(nNum[i] - 1);
            Add(nNum[i], 1);
        }
        memset(nTree, 0, sizeof(nTree));
        for (INT i = nN; i >= 1; --i)
        {
            nRight[0][i] = Query(MAX_N) - Query(nNum[i] - 1);
            nRight[1][i] = Query(nNum[i]);
            Add(nNum[i], 1);
        }
        INT nAns = 0;
        for (INT i = 1; i <= nN; ++i)
        {
            nAns += nLeft[0][i] * nRight[0][i] + nLeft[1][i] * nRight[1][i];
        }
        printf("%I64d\n", nAns);
    }

    return 0;
}

yx 2012-09-12 21:11 发表评论

hdu 3584 Cube 三维树状数组

yx — Mon, 10 Sep 2012 07:43:00 GMT

�q�个题意思是��{一�?1立方体。翻转多�ơ后再查询某个点的倹{�?br /> �q�是利用上一��文章的思想�Q�把��{操作转换为单�Ҏ(gu��)��新操作。把查询操作转换为利用树状数�l�查询和的方式�?br />�q�样每次操作的复杂度都是logN�?�ơ。而直接翻转立方体的复杂度是N�?�ơ�?br /> �q�个题最�ȝ��的地�Ҏ(gu��)��I�间惌��能力。因��{8个点才能完成一�ơ立方体��{。比如，��{(x,y,z)相当�?br />以该点作为左上角做一个无限立方体�Q�把该立方体��{。这样就会翻转多余的部分�Q�那么需要把多翻转的部分��{
回来。最后的思考结果发玎ͼ�只要�Ҏ(gu��)��个顶点翻转一�ơ即可。至于�ؓ什么这��P��自己去计��重复翻转的部分��׃��明白
了。刚好确实是把每个点��{了一�ơ�?br />
代码如下�Q?br />

#include

#include <string.h>
#include
using namespace std;

const int MAX_N = 110;
int nSum[MAX_N + 10][MAX_N + 10][MAX_N + 10];
int nN, nM;

int LowBit(int nPos)
{
    return nPos & (-nPos);
}

void Add(int nX, int nY, int nZ)
{
    for (int i = nX; i <= nN; i += LowBit(i))
    {
        for (int j = nY; j <= nN; j += LowBit(j))
        {
            for (int k = nZ; k <= nN; k += LowBit(k))
            {
                nSum[i][j][k]++;
            }
        }
    }
}

int Query(int nX, int nY, int nZ)
{
    int nAns = 0;

    for (int i = nX; i > 0; i -= LowBit(i))
    {
        for (int j = nY; j > 0; j -= LowBit(j))
        {
            for (int k = nZ; k > 0; k -= LowBit(k))
            {
                nAns += nSum[i][j][k];
            }
        }
    }
    return nAns;
}

int main()
{
    int nCmd;
    int nX, nY, nZ;
    int nX1, nY1, nZ1;
    int nX2, nY2, nZ2;

    while (scanf("%d%d", &nN, &nM) == 2)
    {
        memset(nSum, 0, sizeof(nSum));
        while (nM--)
        {
            scanf("%d", &nCmd);
            if (nCmd == 0)
            {
                scanf("%d%d%d", &nX, &nY, &nZ);
                printf("%d\n", Query(nX, nY, nZ) % 2);
            }
            else
            {
                scanf("%d%d%d%d%d%d", &nX1, &nY1, &nZ1, &nX2, &nY2, &nZ2);
                if (nX1 > nX2)swap(nX1, nX2);
                if (nY1 > nY2)swap(nY1, nY2);
                if (nZ1 > nZ2)swap(nZ1, nZ2);
                Add(nX1, nY1, nZ1);

                Add(nX2 + 1, nY1, nZ1);
                Add(nX1, nY2 + 1, nZ1);
                Add(nX1, nY1, nZ2 + 1);

                Add(nX1, nY2 + 1, nZ2 + 1);
                Add(nX2 + 1, nY1, nZ2 + 1);
                Add(nX2 + 1, nY2 + 1, nZ1);

                Add(nX2 + 1, nY2 + 1, nZ2 + 1);
            }
        }
    }

    return 0;
}

yx 2012-09-10 15:43 发表评论

hdu 1556 Color the ball 树状数组

yx — Thu, 06 Sep 2012 12:51:00 GMT

�q�个题的意思是�l�定一个长为N的区间。不断的�l�某个子区间[A,B]中的每个�Ҏ(gu��)��一�ơ色。最后问每个点的涂色�ơ数�?br /> �q�个题貌似可以扩展到多维的情况，但是多维的情况下必须用树状数�l�求和以加快速度�Q�一�l�的情况直接求和卛_��?br /> 假如�Q�第一�ơ涂色是对区间[A,B]涂色一�ơ，可以让nNum[nA]++,nNum[nB+1]--卛_��。因��样对于区间[0,nA-1]的�Q意值i�?br />都要nNum[1]+nNum[2]+...+nNum[i] = 0。而对于区间[nA,nB]的�Q意值i有nNum[1]+nNum[2]+...+nNum[i] = 0�?br />对于区间[nB+1, nN]的�Q意值i有nNum[1]+nNum[2]+...+nNum[i] = 0�?br /> 那么重复多次了。如果上�q�求和nNum[1]+nNum[2]+...+nNum[i] 刚好代表每个�l�点i的涂色次敎ͼ�那么�q�个题就可解了�?br /> 用例子验证一下，发现肯定是这��L��。证明略了�?br /> 至于树状数组�|�上一大堆资料。树状数�l�模板单一�Q�敲代码太方便了�?br />
代码如下�Q?br />

#include

#include <string.h>
#include
using namespace std;

int nNum[100000 + 10];
int nN;
int LowBit(int nI)
{
    return nI & (-nI);
}

void Add(int nI, int nAdd)
{
    while (nI <= nN)
    {
        nNum[nI] += nAdd;
        nI += LowBit(nI);
    }
}

int GetSum(int nI)
{
    int nAns = 0;

    while (nI > 0)
    {
        nAns += nNum[nI];
        nI -= LowBit(nI);
    }
    return nAns;
}

int main()
{
    int nA, nB;

    while (scanf("%d", &nN), nN)
    {
        memset(nNum, 0, sizeof(nNum));

        for (int i = 1; i <= nN; ++i)
        {
            scanf("%d%d", &nA, &nB);
            Add(nA, 1);
            Add(nB + 1, -1);
        }
        for (int i = 1; i <= nN; ++i)
        {
            printf("%d%s", GetSum(i), i == nN ? "\n" : " ");
        }
    }

    return 0;
}

yx 2012-09-06 20:51 发表评论

poj 2823 Sliding Window 单调队列

yx — Sun, 02 Sep 2012 06:25:00 GMT

�q�道题的意思是�l�定一个长N的整数序列，用一个大��ؓK的窗口从头开始覆盖，问第1-�W�N-K�ơ窗口里面最大的数字和最��的数字�?br /> 刚开始还以�ؓ优先�U�队列可以做�Q�发现无法删除最前面的元素。估计用�U�段树这个题也是可以解得。用�q�个题学了下单调队列�?br />
单调队列正如其名�Q�是一个从��到大排序的队列�Q�而且能够保证所有的元素入队列一�ơ出队列一�ơ，所以��^摊到每个元素的复杂度
��是O(1)�?br /> 对于�q�个题单调队列的使用。以序列1 3 -1 -3 5 3 6 7举例�?/span>
1�Q�元素类型：一个结构体�Q�包含数字大��和位置�Q�比�?1�Q?�Q�，�Q?�Q?�Q��?br /> 2�Q�插入操作：从队��ּ�始查找，把队��ְ�于待插入元素的元素全部删除，再加入待插入的元素。这个操作最坏的
情况下是O(n)�Q�但是我们采用聚集分析的�Ҏ(gu��)��Q�知道每个元素最多删除一�ơ，那么N个元素删除N�ơ，�q�x��到每一��?br />操作的复杂度��是O(1)了�?br /> 3�Q�删除队首元素：比如本文�l�的那个题，�H�口一直往后移动，每一�ơ移动都会删除一个元素，所以很可能队首会是�?br />删除的元素，那么每次�U�d��H�口的元素要�q�行一�ơ检查，如果队首元素失效的话�Q�就删掉队首元素�?br />
代码的实玎ͼ�我是包装deque实现了一个模版类。速度很不好，居然跑了11s多才�q�，�q怺��l�了12s的时��_��看status�?00多ms
��p��了的。估计数�l�实��C��快很多�?br />
代码如下�Q?br />

#include
#include
#include
using namespace std;
#define MAX_N (1000000 + 100)
int nNum[MAX_N];
int nN, nK;

struct Small
{
    int nValue;
    int nIndex;
    Small(int nV, int index):nValue(nV), nIndex(index) {}
    bool operator < (const Small& a) const
    {
        return nValue < a.nValue;
    }
};

struct Big
{
    int nValue;
    int nIndex;
    Big(int nV, int index):nValue(nV), nIndex(index) {}
    bool operator < (const Big& a) const
    {
        return nValue > a.nValue;
    }
};

//单调队列
template  class Monoque
{
    deque dn;

public:
    void Insert(T node)
    {
        int nPos = dn.size() - 1;
        while (nPos >=0 && node < dn[nPos])
        {
            --nPos;
            dn.pop_back();
        }
        dn.push_back(node);
    }

    int Top()
    {
        return dn.front().nValue;
    }

    void Del(int nBeg, int nEnd)
    {
        if (dn.size() > 0)
        {
            if (dn.front().nIndex < nBeg || dn.front().nIndex > nEnd)
            {
                dn.pop_front();
            }
        }
    }
};

int main()
{
    while (scanf("%d%d", &nN, &nK) == 2)
    {
        int i;
        for (i = 0; i < nN; ++i)
        {
            scanf("%d", &nNum[i]);
        }
        Monoque minQ;
        Monoque maxQ;

        for (i = 0; i < nK; ++i)
        {
            minQ.Insert(Small(nNum[i], i));
        }

        for (i = 0; i < nN - nK; ++i)
        {
            printf("%d ", minQ.Top());
            minQ.Insert(Small(nNum[i + nK], i + nK));
            minQ.Del(i + 1, i + nK);
        }
        printf("%d\n", minQ.Top());

        for (i = 0; i < nK; ++i)
        {
            maxQ.Insert(Big(nNum[i], i));
        }

        for (i = 0; i < nN - nK; ++i)
        {
            printf("%d ", maxQ.Top());
            maxQ.Insert(Big(nNum[i + nK], i + nK));
            maxQ.Del(i + 1, i + nK);
        }
        printf("%d\n", maxQ.Top());
    }

    return 0;
}

yx 2012-09-02 14:25 发表评论

hdu 3627 Giant For

yx — Thu, 26 Jul 2012 04:22:00 GMT

�q�个题是对可排序数据的实时增加删除查找，那天做比赛的时候一炚w��不会�Q�想来想去觉得��^衡树可以做，但是写��^衡树是�g很难的事情�?br />后面知道�U�段数可以做�Q�虽然数据的范围很大�Q�但是可以在全部��d��数据后排序再��L��化，然后�q�行�U�段树的操作�Q�具体的代码没有写�?br /> 今天队友在网上发��C��U�用map和set可以水掉�q�题的方法。原来，�q�个�Ҏ(gu��)��最主要的��用了map和set里面的upper_bound操作�Q�以�?br />居然忘记了这个东西了。既然这��P��map和set也可以查前驱和后�l�了�Q�但是注意low_bound查到的是��于�{�于的键。这个代码，注意是用
了一个map< int, set > 集合把坐标都存�v来了�Q�进行添加删除和查找后��的操作。由于查��N��要查扄��元素是既比x大又比y大的�?br />素，��比较麻烦，需要��@环x往后查找，但是�q�样��无情的��时了。然后，有一个优化，记录y的数目，那么当出现很大的y的时候，��׃��需�?br />查找了，然后才过了这个题。但是，数据变成很大的y对应的x很小的话�Q�那么绝对过不了�q�个题了�Q�只能用�U�段树做了�?br /> 现在觉得用map和set查找前驱和后�l�确实能水掉一些题啊�?br />
代码如下�Q?br />

#include
#include <set>
#include
using namespace std;

map< int, set<int> > ms;//存储x,y
map< int, set<int> >::iterator it;
map<int, int> my;//存储y的数�?/span>
set<int>::iterator msit;
int main()
{
    int nN;
    int nCase = 1;
    char szCmd[10];
    int nX, nY;
    int nTemp;

    while(scanf("%d", &nN), nN)
    {
        if (nCase > 1)
        {
            printf("\n");
        }

        printf("Case %d:\n", nCase++);
        ms.clear();
        my.clear();
        while (nN--)
        {
            scanf("%s", szCmd);
            scanf("%d%d", &nX, &nY);
            if (szCmd[0] == 'a')
            {
                if (my.find(nY) == my.end())
                {
                    my[nY] = 1;
                }
                else
                {
                    my[nY]++;
                }

                if (ms.find(nX) == ms.end())
                {
                    ms[nX].insert(nY);
                }
                else
                {
                    msit = ms[nX].find(nY);
                    if (msit == ms[nX].end())//会出现重复的数据
                    {
                        ms[nX].insert(nY);
                    }
                }
            }
            else if (szCmd[0] == 'r')
            {
                ms[nX].erase(nY);
                if(ms[nX].size() == 0)
                {
                    ms.erase(nX);
                }
                my[nY]--;
                if (my[nY] == 0)
                {
                    my.erase(nY);
                }
            }
            else if (szCmd[0] == 'f')
            {
                if (my.upper_bound(nY) == my.end())
                {
                    printf("-1\n");
                    continue;
                }
                while (true)
                {
                    it = ms.upper_bound(nX);
                    if (it == ms.end())//比nX大的不存�?/span>
                    {
                        printf("-1\n");
                        break;
                    }
                    nTemp = it->first;
                    msit = ms[nTemp].upper_bound(nY);
                    if (msit == ms[nTemp].end())//比nY大的不存�?/span>
                    {
                        nX = nTemp;
                        continue;//那么增加x,�l�箋往后查
                    }
                    else
                    {
                        printf("%d %d\n", nTemp, *msit);
                        break;
                    }
                }
            }
        }
    }

    return 0;
}

yx 2012-07-26 12:22 发表评论

uva 10562 - Undraw the Trees

yx — Tue, 10 Jul 2012 13:35:00 GMT

�q�是一个貌似很�ȝ��的题�Q�题目要求是��一颗用ascii码绘��d��来的树，转换为其一�U�字�W�串表示�Q�这�U�字�W�串表示好像是叫做什么广义表
什么的�?br /> 比如�Q?br /> A

--------

B C D

| |

----- -

E F G 对应的字�W�串表示 (A(B()C(E()F())D(G())))

比较�U�结的是如何��d��数据�Q�如何递归�Q�如果徏立树的话�Q�也�ȝ��Q�因��是颗不定叉的树。最主要的是如何方便地递归。最后知道了一�?br />比较巧妙的方法，先一�ơ性把一�l�数据读入字�W�串数组里面�Q�再在这个字�W�串数组上进行递归处理。这��L��话，��p��很方便的扑ֈ�树里面节�?br />的关�p�M��?br /> 而一�ơ读一个字�W�就惌��行递归是没办法��定节点的关�pȝ��Q�不递归估计更很隑ֆ��Q�完全没头��A。。�?br />
代码如下�Q?br />

1 #include
2 #include <string.h>
3
4 char szLines[210][210];
5 int nNumOfLine;
6
7 void GetAns(int i, int j)
8 {
9     //printf("i:%d, j:%d, %c\n", i, j, szLines[i][j]);
10
11     if (szLines[i][j] != '\0')
12     {
13         putchar(szLines[i][j]);
14         //printf("%c", szLines[i + 1][j]);
15         if (szLines[i + 1][j] == '|')
16         {
17             int nBeg, nEnd;
18             nBeg = nEnd = j;
19             while (nBeg >= 0 && szLines[i + 2][nBeg] == '-')
20             {
21                 --nBeg;
22             }
23             while (szLines[i + 2][nEnd] == '-')
24             {
25                 ++nEnd;
26             }
27             //printf("nBeg:%d, nEnd:%d\n", nBeg, nEnd);
28             putchar('(');
29             for (int k = nBeg; k <= nEnd; ++k)
30             {
31                 if (szLines[i + 3][k] != ' ' && szLines[i + 3][k] != '\0')
32                 {
33                     GetAns(i + 3, k);
34                 }
35             }
36             putchar(')');
37         }
38         else
39         {
40             printf("()");
41         }
42     }
43
44 }
45
46 int main()
47 {
48     int nN;
49     char ch;
50
51     scanf("%d", &nN);
52     getchar();
53     while (nN--)
54     {
55         nNumOfLine = 0;
56         memset(szLines, 0, sizeof(szLines));
57         while (gets(szLines[nNumOfLine]), szLines[nNumOfLine][0] != '#')
58         {
59             //printf("%s\n", szLines[nNumOfLine]);
60             nNumOfLine++;
61         }
62         if (nNumOfLine == 0)
63         {
64             printf("()\n");
65             continue;
66         }
67         int i, j;
68         i = 0;
69         for (j = 0; szLines[0][j] == ' '; ++j);
70         //printf("i:%d, j:%d\n", i, j);
71         putchar('(');
72         GetAns(i, j);
73         putchar(')');
74         putchar('\n');
75     }
76
77     return 0;
78 }
79

yx 2012-07-10 21:35 发表评论

uva 327 - Evaluating Simple C Expressions

yx — Tue, 10 Jul 2012 04:05:00 GMT

�q�个题目的意思是要计��一些c语言表达式的倹{��这些表辑ּ��?-�q�有++�Q?-操作�W�与a-z�q�些变量�l�合而成。a-z的权值是1-26�?br />比如�Q�表辑ּ� c+f--+--a�Q�得出值是9�Q�其它变量的��g��需要计��出来�?/span>
�q�个题目感觉比较�ȝ��Q�刚开始一�Ҏ(gu��)��\也没有，�q�写了个错误的方法，��费了时间�?br /> 后面我的思�\�?�Q?�Q?�Q?�Q?-�Q?+�Q�（变量�Q�（--�Q?+�Q�，�q�个匚w��式子的意思是先处理二元操作符�Q�然后处理前�|�，再处理变量，
再处理后�|�，如果发现没有后置操作�W�，则把��d��的数据重新写回数据流里面�Q�下�ơ再处理�?br />
代码如下�Q?span style="font-size: 13px; color: #008080; ">

  1 #include
2 #include <string.h>
  3 #include
  4 #include
  5 using namespace std;
  6 struct INFO
  7 {
  8     char ch;
  9     int nValue;
10     char chAdd;
11     bool operator < (const INFO& info) const
12     {
13         return ch < info.ch;
14     }
15 };
16
17 INFO infos[200];
18 char szLine[200];
19
20 bool GetNextChar(stringstream& ss, char& ch)
21 {
22     while (ss >> ch)
23     {
24         if (ch != ' ');
25         {
26             return true;
27         }
28     }
29     return false;
30 }
31
32 int main()
33 {
34     while (gets(szLine))
35     {
36         printf("Expression: %s\n", szLine);
37         memset(infos, 0, sizeof(infos));
38         stringstream ss(szLine);
39         char ch;
40         int nNum = 0;
41         int nValue = 0;
42         char chOper;
43         bool bOk = true;
44         bool bFirst = true;
45         while (1)
46         {
47             if (bFirst)
48             {
49                 chOper = '+';
50                 bFirst = false;
51             }
52             else
53             {
54                 bOk = GetNextChar(ss, ch);
55                 if (!bOk) break;
56                 chOper = ch;
57             }
58
59             bOk = GetNextChar(ss, ch);
60             if (!bOk) break;
61
62             if (ch == '-')//前置--
63             {
64                 bOk = GetNextChar(ss, ch);
65                 if (!bOk) break;//-
66                 bOk = GetNextChar(ss, ch);
67                 if (!bOk) break;//��d��字母
68
69                 infos[nNum].ch = ch;
70                 infos[nNum].nValue = ch - 'a';
71
72                 if (chOper == '+')
73                 {
74                     nValue += infos[nNum].nValue;
75                 }
76                 else
77                 {
78                     nValue -= infos[nNum].nValue;
79                 }
80                 ++nNum;
81             }
82             else if (ch == '+')//前置++
83             {
84                 bOk = GetNextChar(ss, ch);
85                 if (!bOk) break;//+
86                 bOk = GetNextChar(ss, ch);
87                 if (!bOk) break;//��d��字母
88
89                 infos[nNum].ch = ch;
90                 infos[nNum].nValue = ch - 'a' + 2;
91
92                 if (chOper == '+')
93                 {
94                     nValue += infos[nNum].nValue;
95                 }
96                 else
97                 {
98                     nValue -= infos[nNum].nValue;
99                 }
100                 ++nNum;
101             }
102             else
103             {
104                 infos[nNum].ch = ch;
105                 infos[nNum].nValue = ch - 'a' + 1;
106
107                 if (chOper == '+')
108                 {
109                     nValue += infos[nNum].nValue;
110                 }
111                 else
112                 {
113                     nValue -= infos[nNum].nValue;
114                 }
115
116                 //��d��后置操作�W?/span>
117                 char chOne;
118                 char chTwo;
119                 bOk = GetNextChar(ss, chOne);
120                 if (!bOk)
121                 {
122                     ++nNum;
123                     break;
124                 }
125                 bOk = GetNextChar(ss, chTwo);
126                 if (!bOk)
127                 {
128                     ++nNum;
129                     break;
130                 }
131
132                 if (chOne == chTwo)
133                 {
134                     if (chOne == '+')
135                     {
136                         infos[nNum].chAdd = '+';
137                     }
138                     else
139                     {
140                         infos[nNum].chAdd = '-';
141                     }
142                 }
143                 else
144                 {
145                     ss.putback(chTwo);
146                     ss.putback(chOne);
147                 }
148                 ++nNum;
149             }
150         }
151
152         printf("    value = %d\n", nValue);
153         sort(infos, infos + nNum);
154         for (int i = 0; i < nNum; ++i)
155         {
156             if (infos[i].chAdd == '+')
157             {
158                 infos[i].nValue++;
159             }
160             else if (infos[i].chAdd == '-')
161             {
162                 infos[i].nValue--;
163             }
164             printf("    %c = %d\n", infos[i].ch, infos[i].nValue);
165         }
166     }
167
168     return 0;
169 }
170

yx 2012-07-10 12:05 发表评论

uva 297 - Quadtrees

yx — Sun, 08 Jul 2012 03:06:00 GMT

题意是用字符串描�q�的一��四叉树�Q�读取字�W�串获得最�l�叶子节点的颜色。输入是2个字�W�串�Q�根据这2个字�W�串建立2个四叉树。然后对于，指定位置的叶子节点，如果2颗树的叶子颜色其中一个�ؓ黑色�Q�那么ans++�Q�输出的��是ans�?br /> �c�M��树�Ş�l�构的东西，直接一个函数递归求解卛_��。函数参敎ͼ�一般是字符串地址�Q�当前位�|�，然后�q�有其它在递归时候需要用到的东西�?br />
代码如下�Q?font size="2">

1 #include
2 #define BLACK (1)
3 #define WHITE (2)
4 #define MAX (32)
5 int nStateA[MAX][MAX];
6 int nStateB[MAX][MAX];
7
8 char szOne[10000];
9 char szTwo[10000];
10
11 void GetState(int nState[MAX][MAX], char* pszLine, int& nPos,
12               int nSize, int nX, int nY)
13 {
14     if (pszLine[nPos] == 'p')
15     {
16         ++nPos;
17         GetState(nState, pszLine, nPos, nSize / 2, nX + nSize / 2, nY);
18         GetState(nState, pszLine, nPos, nSize / 2, nX, nY);
19         GetState(nState, pszLine, nPos, nSize / 2, nX, nY + nSize / 2);
20         GetState(nState, pszLine, nPos, nSize / 2, nX + nSize / 2, nY + nSize / 2);
21     }
22     else
23     {
24         for (int i = nX; i < nX + nSize; ++i)
25         {
26             for (int j = nY; j < nY + nSize; ++j)
27             {
28                 if (pszLine[nPos] == 'e')
29                 {
30
31                     nState[i][j] = WHITE;
32                 }
33                 else
34                 {
35                     nState[i][j] = BLACK;
36                 }
37             }
38         }
39         ++nPos;
40     }
41 }
42
43 int main()
44 {
45     int nCases;
46
47     scanf("%d\n", &nCases);
48     while (nCases--)
49     {
50         gets(szOne);
51         gets(szTwo);
52         int nPos = 0;
53         GetState(nStateA, szOne, nPos, MAX, 0, 0);
54         nPos = 0;
55         GetState(nStateB, szTwo, nPos, MAX, 0, 0);
56         int nAns = 0;
57
58         for (int i = 0; i < MAX; ++i)
59         {
60             for (int j = 0; j < MAX; ++j)
61             {
62                 if (nStateA[i][j] == BLACK || nStateB[i][j] == BLACK)
63                 {
64                     nAns++;
65                 }
66             }
67         }
68         printf("There are %d black pixels.\n", nAns);
69     }
70
71     return 0;
72 }
73

yx 2012-07-08 11:06 发表评论

无穷大数�l�上如何直接��d��来实现字典？

yx — Tue, 20 Mar 2012 11:26:00 GMT

�q�是��法��D��习题11.1-4�?br /> 具体题目如下�Q?br />

解决该题目的要点�Q?br /> 1.�׃��是无�I�大的数�l�，所以无法事先初始化该数�l��?br /> 2.所提供的方案必��L��O�Q?�Q��?br /> 3.使用的额外空间只能是O�Q�n�Q�，�q�样�q�_��到每一个项上的�I�间都是O�Q?�Q��?br />
一时之间好像没有一点头�l�，在几个群里面发问了，�|�上搜了很久也没有找到答案，后面一��里有个高�h�l�了个链接，里面有解法�?br />链接地址�Q�http://www.cnblogs.com/flyfy1/archive/2011/03/05/1971502.html�Q�这��文章里面另外给了个pdf�Q�这个pdf估计是解�?br />的来源。伪代码写得不给力，不过前面的英文描�q�却很清晰。说实话�Q�这个方法很巧妙�?br />
解法大概的意思如下：
   开一个额外的数组A�Q�A[0]表示A数组元素的数�?当然不包括A[0]本��n)�Q�A[i]代表插入的第i个元素的key。假讑֎�来的无穷大数�l�用Huge
表示�Q�如果Huge[i](直接��d��Q�假设i��是key)有效�Q�则表示其在A数组中的索引。那么如果A[Huge[i]] == i 而且 Huge[i] <= A[0] &&
Huge[i] > 0�Q�则表示i�q�个位置已经有元素插入了�?br />
插入�Q�A[0]++;A[A[0]] = key; Huge[key] = A[0];
搜烦: A[Huge[i]] == i && Huge[i] <= A[0] && Huge[i] > 0 则return true;
删除: 先搜索该位置是否有元�? 如果Search(key)成功�Q�则先把Huge[ A[A[0]] ] = Huge[key]�Q?br />            然后交换A[A[0]]和A[Huge[key]]�Q�A[0]--卛_��?br /> 所有操作都是O�Q?�Q�，�q�_��到每一个项�Q��用的�I�间都是O�Q?�Q��?br />
我用代码实现的模拟如下：

#include
#include
#include
using std::swap;
using std::vector;
#define INF (100)

int nHuge[INF];//假设�q�个巨大的数�l�是无法初始化的
vector<int> vA;

void Init()
{
    vA.push_back(0);//��d��A[0]表示元素的数�?/span>
}

void Insert(int nKey)
{
    vA[0]++;
    nHuge[nKey] = vA[0];
    vA.push_back(nKey);
}

bool Search(int nKey)
{
    if (nHuge[nKey] > 0 && nHuge[nKey] <= vA[0] && vA[nHuge[nKey]] == nKey)
    {
        return true;
    }

    return false;
}

void Delete(int nKey)
{
    if (Search(nKey))
    {
        nHuge[ vA[vA[0]] ] = nHuge[nKey];//��huge的最后一个元素中存储的A数组的烦引改为nHuge[nKey]
        swap(vA[vA[0]], vA[nHuge[nKey]]);//交换key
        --vA[0];

vA.erase(vA.end() - 1);

    }
}

#define MAX (10)
int main()
{
    Init();
    int i;
    for (i = 0; i < MAX; ++i)
    {
        Insert(i);
    }
    for (i = 0; i < MAX; ++i)
    {
        printf("Search:%d %s\n", i, Search(i) == true? "Success" : "Failure");
    }
    printf("\n");

    Delete(4);
    Delete(9);
    Delete(1);
    for (i = 0; i < MAX * 2; ++i)
    {
        printf("Search:%d %s\n", i, Search(i) == true? "Success" : "Failure");
    }

    return 0;
}

yx 2012-03-20 19:26 发表评论

两个栈实��C��个队�?�?两个队列实现一个栈

yx — Sun, 11 Mar 2012 12:30:00 GMT

两个栈实��C��个队�?br /> 要求�Q�只能��用栈的pop和push�Q�以及测试栈是否为空三个操作�?br /> 实现思�\�Q?br /> 队列里面使用stack one �?stack two�?br /> �q�队列时�Q�直接进入栈one卛_��?br /> 出队列时�Q�从two弹出一个元素，如果two里面的元素�ؓ�I�，则将one里面的元素依�ơ弹出�ƈ压入two中，再从two弹出一个元素返回�?br />
用STL里面的stack模拟实现queue的代码如下：
1 #include <stdio.h>

  2 #include
  3 #include
  4 #include
  5 using std::stack;
  6
  7 template<class T> class CQueue
  8 {
  9 public:
10     CQueue()
11     {
12         nSize = 0;
13     }
14
15     void clear()
16     {
17         while (!one.empty())
18         {
19             one.pop();
20         }
21         while (!two.empty())
22         {
23             two.pop();
24         }
25     }
26
27     void push(const T& t)
28     {
29         one.push(t);
30         ++nSize;
31     }
32
33     void pop()
34     {
35         if (two.empty())
36         {
37             while (!one.empty())
38             {
39                 two.push(one.top());
40                 one.pop();
41             }
42         }
43         two.pop();
44         --nSize;
45     }
46
47     T& front()
48     {
49         if (two.empty())
50         {
51             while (!one.empty())
52             {
53                 two.push(one.top());
54                 one.pop();
55             }
56         }
57         return two.top();
58     }
59
60     T& back()
61     {
62         return one.top();
63     }
64
65     bool empty()
66     {
67         return nSize == 0;
68     }
69
70 private:
71     stack one;
72     stack two;
73     int nSize;
74 };
75
76 #define MAX 20
77
78 int main()
79 {
80     CQueue<int> q;
81
82     srand(time(NULL));
83     for (int i = 0; i < MAX; ++i)
84     {
85         q.push(i);
86
87         if (rand() % 2)
88         {
89             printf("front: %d\n", q.front());
90             q.pop();
91         }
92     }
93
94     while (!q.empty())
95     {
96         printf("front: %d\n", q.front());
97         q.pop();
98     }
99
100     return 0;
101 }
102

两个队列实现一个栈
   要求�Q�只能��用从队列的尾部入和头部出�Q�以及测试队列是否�ؓ�I�Z��个操作�?br /> 实现思�\�Q?br />      队列里面使用queue one �?stack two�?br />      �q�栈�Ӟ��Ҏ(gu��)��当前元素是全部存储在哪个队列而选择从one或者two的尾部进入�?br /> 出栈�Ӟ��假设当前元素都存储在one里面�Q�则不断出队列，直到队列为空之前的所有元素一�ơ进入队列two�Q�而one里面的最后一个元�?br />      作�ؓ栈弹出的��D��回�?br /> 对于当前元素是存储在哪个队列里面�Q�可以设�|�变量标讎ͼ�初始化时候存储在one里面�Q�操作一�ơ，�׃��元素要倒�{�Q�则存储位置会变
      一�ơ�?br />
用STL里面的queue模拟实现的stack代码如下�Q?br /> 1 #include <stdio.h>

  2 #include
  3 using std::queue;
  4
  5 template<class T> class CStack
  6 {
  7 public:
  8     CStack()
  9     {
10         nSize = 0;
11         nTime = 1;
12     }
13
14     void clear()
15     {
16         while (!one.empty())
17         {
18             one.pop();
19         }
20         while (!two.empty())
21         {
22             two.pop();
23         }
24     }
25
26     void push(const T& t)
27     {
28         if (nTime % 2)
29         {
30             one.push(t);
31         }
32         else
33         {
34             two.push(t);
35         }
36         ++nSize;
37     }
38
39     void pop()
40     {
41         if (nTime % 2)
42         {
43             while (!one.empty())
44             {
45                 T t = one.front();
46                 one.pop();
47                 if (!one.empty())
48                 {
49                     two.push(t);
50                 }
51             }
52         }
53         else
54         {
55             while (!two.empty())
56             {
57                 T t = two.front();
58                 two.pop();
59                 if (!two.empty())
60                 {
61                     one.push(t);
62                 }
63             }
64         }
65
66         nTime = (nTime + 1) % 2;
67         --nSize;
68     }
69
70     T& top()
71     {
72         if (nTime % 2)
73         {
74             while (!one.empty())
75             {
76                 T t = one.front();
77                 one.pop();
78                 if (!one.empty())
79                 {
80                     two.push(t);
81                 }
82                 else
83                 {
84                     two.push(t);
85                     nTime = (nTime + 1) % 2;
86                     return two.back();
87                 }
88             }
89         }
90         else
91         {
92             while (!two.empty())
93             {
94                 T t = two.front();
95                 two.pop();
96                 if (!two.empty())
97                 {
98                     one.push(t);
99                 }
100                 else
101                 {
102                     one.push(t);
103                     nTime = (nTime + 1) % 2;
104                     return one.back();
105                 }
106             }
107         }
108     }
109
110     bool empty()
111     {
112         return nSize == 0;
113     }
114
115 private:
116     queue one;
117     queue two;
118     int nSize;
119     int nTime;
120 };
121
122 #define MAX 20
123
124 int main()
125 {
126     CStack<int> stack;
127
128     for (int i = 0; i < MAX; ++i)
129     {
130         stack.push(i);
131     }
132
133     while (!stack.empty())
134     {
135         printf("top: %d\n", stack.top());
136         stack.pop();
137     }
138
139     return 0;
140 }
141

yx 2012-03-11 20:30 发表评论

POJ癄�� - 2797:最短前�~�(可以使用字典树做)

yx — Tue, 22 Nov 2011 07:11:00 GMT

链接: http://poj.grids.cn/practice/2797/

�q�题乍看之下��实没什么思�\,后面�l�于明白题意�?然后�H�然惛_��可以用字典树�?速度当然会是非常快的...
但是其实�q�有一�U�更��单的�Ҏ(gu��)��,那就是对所有字�W�串排序之后,每个字符串的前缀长度其实��是由其前一个和后一个字�W�串共同军_��,
nLen = max(nOne, nTwo), nOne �?nTwo��分别代表当前字�W�串和前后字�W�串公告部分的长�?1后的�?..
代码写出来写非常��?..同学�q�样实现了下,也轻松过�?..

然后我就辛苦的写了一��字典树...可能我的写法不是很标�?因�ؓ我没参考什么模�?自己��想出来怎么写的...
我的��x��是开一个静态大数组,�W�一个结点作为根,不存储数�?从第二个�l�点开始作��q��间分�?..
其实,��是�?6颗字典树虚拟了个无数据的根结�?..
使用了虚拟的根结点后,代码比用26个根�l�点��z�很�?..
刚开始我��假�?-26��L��点分别�ؓa-z,作�ؓ26颗树的根,
而且�?6个结点的位置我用的是索引,没用指针,后面换成了指�?代码看�v来更舒服�?..

#include

#define LETTER_NUM 26

#define WORD_LEN_MAX 25

#define WORD_NUM_MAX 1030

#define NODE_MAX (WORD_LEN_MAX * WORD_NUM_MAX + 10)

struct WORD_TREE

{

char ch;

WORD_TREE* next[LETTER_NUM];

int nTime;

};

WORD_TREE tree[NODE_MAX];

WORD_TREE* pFreeNode = tree + 1;//�W�一个结点作为头�l�点,不存储数�?/div>

char szWords[WORD_NUM_MAX][WORD_LEN_MAX];

void AddToTree(char* pszStr)

{

WORD_TREE* pTree = tree;

while (*pszStr && pTree->next[*pszStr - 'a'])

{

pTree = pTree->next[*pszStr - 'a'];

pTree->nTime++;

++pszStr;

}

while (*pszStr)

{

pFreeNode->ch = *pszStr;

pFreeNode->nTime++;

pTree->next[*pszStr - 'a'] = pFreeNode;

pTree = pFreeNode;

++pszStr;

++pFreeNode;

}

int FindPrefix(char* pszStr)

{

WORD_TREE* pTree = tree;

int nLen = 0;

while (*pszStr)

{

++nLen;

pTree = pTree->next[*pszStr - 'a'];

if (pTree->nTime <= 1)

{

break;

}

++pszStr;

}

return nLen;

}

int main()

{

int nCount = 0;

while (scanf("%s", szWords[nCount]) != EOF)

{

AddToTree(szWords[nCount]);

nCount++;

}

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

{

int nLen = FindPrefix(szWords[i]);

printf("%s ", szWords[i]);

for (int j = 0; j < nLen; ++j)

{

putchar(szWords[i][j]);

}

putchar('\n');

}

return 0;

}

yx 2011-11-22 15:11 发表评论

国产V亚洲V天堂无码久久久 ,亚洲精品无码久久久久久,久久国产香蕉视频

poj 3264 Balanced Lineup St���法建立Rmq

poj 3764 The xor-longest Path 字典�?+ Xor

poj 2886 Who Gets the Most Candies? �U�瑟夫环和反素数

hdu 2492 Ping pong 树状数组

hdu 3584 Cube 三维树状数组

hdu 1556 Color the ball 树状数组

poj 2823 Sliding Window 单调队列

hdu 3627 Giant For

uva 10562 - Undraw the Trees

uva 327 - Evaluating Simple C Expressions

uva 297 - Quadtrees

无穷大数�l�上如何直接��d��来实现字典？

两个栈实��C��个队�?�?两个队列实现一个栈

POJ癄��� - 2797:最短前�~�(可以使用字典树做)

poj 3264 Balanced Lineup St��法建立Rmq

POJ癄�� - 2797:最短前�~�(可以使用字典树做)