【Tsinghua OJ】祖瑪(Zuma)問題

描述

祖瑪是一款曾經風靡全球的游戲，其玩法是：在一條軌道上初始排列着若干個彩色珠子，其中任意三個相鄰的珠子不會完全同色。此后，你可以發射珠子到軌 道上並加入原有序列中。一旦有三個或更多同色的珠子變成相鄰，它們就會立即消失。這類消除現象可能會連鎖式發生，其間你將暫時不能發射珠子。

開發商最近准備為玩家寫一個游戲過程的回放工具。他們已經在游戲內完成了過程記錄的功能，而回放功能的實現則委托你來完成。

游戲過程的記錄中，首先是軌道上初始的珠子序列，然后是玩家接下來所做的一系列操作。你的任務是，在各次操作之后及時計算出新的珠子序列。

輸入

第一行是一個由大寫字母'A'~'Z'組成的字符串，表示軌道上初始的珠子序列，不同的字母表示不同的顏色。

第二行是一個數字n，表示整個回放過程共有n次操作。

接下來的n行依次對應於各次操作。每次操作由一個數字k和一個大寫字母Σ描述，以空格分隔。其中，Σ為新珠子的顏色。若插入前共有m顆珠子，則k ∈ [0, m]表示新珠子嵌入之后（尚未發生消除之前）在軌道上的位序。

輸出

輸出共n行，依次給出各次操作（及可能隨即發生的消除現象）之后軌道上的珠子序列。

如果軌道上已沒有珠子，則以“-”表示。

輸入樣例

ACCBA
5
1 B
0 A
2 B
4 C
0 A

輸出樣例

ABCCBA
AABCCBA
AABBCCBA
-
A

限制

0 ≤ n ≤ 10^4

0 ≤ 初始珠子數量 ≤ 10^4

時間：2s，內存：256MB

提示

列表

 

---

 

 

【Solution】

先貼源碼：

#include <stdio.h>
#include "string.h"
#include <stdlib.h>

typedef char ElemType;
typedef struct node
{
    ElemType data;
    struct node *next;
    struct node *front;
}List, *pList;

pList pHead = (pList)malloc(sizeof(List));
pList pTail = (pList)malloc(sizeof(List));

void creat(char *a, int n)
{
    int i;
    pList pt = pHead;

    pTail->front = pHead;
    pTail->next = NULL;
    pHead->next = pTail;
    pHead->front = NULL;
    pHead->data = pTail->data = '-';

    for (i = 0; i < n; i++)
    {
        pList pNew = (pList)malloc(sizeof(List));
        pNew->data = a[i];
        pNew->front = pt;
        pNew->next = pt->next;
        pt->next->front = pNew;
        pt->next = pNew;
        pt = pNew;
    }
}

void insert(int m, char ch)
{
    int i = -1;
    pList pt = pHead, pNew = (pList)malloc(sizeof(List));

    while (i++ < m) pt = pt->next;
    
    pNew->data = ch;
    pNew->next = pt;
    pNew->front = pt->front;
    pt->front->next = pNew;
    pt->front = pNew;
}

void del(int m)
{
    pList p1 = NULL, p2 = NULL, p3 = NULL, p4 = NULL, pt = pHead;
    pList begin = pHead, end = pTail;
    bool boo = true;
    int repeat, i = -1;

    // find position
    while (i++ < m - 2) pt = pt->next;

    //init for 'begin' and 'end'
    begin = pt; end = pt; i = 0;
    while (i++ < 4 && end->next != pTail) end = end->next;

    while (boo && pt != pTail)
    {
        boo = false; repeat = 1;
        while (pt != end)
        {
            pt = pt->next;

            if (pt->front->data == pt->data) repeat++;
            else repeat = 1;

            if (repeat == 3)
            {
                boo = true;
                if (pt->data == pt->next->data)
                {
                    repeat++;
                    pt = pt->next;
                }

                if (repeat == 3)
                {
                    p3 = pt; p2 = p3->front; p1 = p2->front;
                    p1->front->next = p3->next;
                    p3->next->front = p1->front;
                    pt = pt->next;
                    delete p1; delete p2; delete p3;
                }
                else
                {
                    p4 = pt; p3 = p4->front; p2 = p3->front; p1 = p2->front;
                    p1->front->next = p4->next;
                    p4->next->front = p1->front;
                    pt = pt->next;
                    delete p1; delete p2; delete p3; delete p4;
                }

                break;
            }
        }

        if (boo && pt != pTail)
        {
            begin = pt; i = 0;
            while (i++ < 2 && begin->front != pHead) begin = begin->front;
            end = pt; i = 0;
            if (i++ < 1 && end->next != pTail) end = end->next;
            pt = begin;
        }
    }
}

void show()
{
    pList pt = pHead->next;

    if (pt == pTail) printf("-");
    else
    {
        while (pt->next != NULL)
        {
            printf("%c", pt->data);
            pt = pt->next;
        }
    }

    printf("\n");
}

int main(void)
{
    char a[10005];
    int n, k;
    pList pHead = NULL;

    gets(a);
    scanf("%d\n", &n);

    creat(a, strlen(a));

    for (k = 0; k < n; k++)
    {
        int m;
        char ch;

        scanf("%d ", &m);
        do
        {
            ch = getchar();
        } while (!((ch >= 'A') && (ch <= 'Z')));

        // insert ch
        insert(m, ch);  

        // delete all 3-same block, making it the right string
        del(m);

        // print the string
        show();
    }

    return 0;
}

 

可以過 Tsinghua OJ 95%的數據，最后一個點超時，聽說要把緩存區調大或者用fread讀取數據才能過，暫時無解。

這一類題屬於模擬題，也就是按照題意一步一步模擬操作即可，對現實事物的合理抽象以及模擬操作的效率是解決問題的關鍵。

 

要注意的幾個點：

1、注意列表與向量數據結構的差別。向量可以直接 “循秩訪問(call-by-rank)”，所以對於查找操作是O(1)的，插入和刪除都是O(n)的，對於二分查找等這樣十分依賴於“秩”的算法很重要；而列表是“循位置訪問(call-by-position)”，所以對於 插入、刪除都是O(1)的操作，而查找操作是O(n)的。要充分注意它們的特點。實際上，對於這道題，雖然提示里寫了“列表”，由於每次都要遍歷輸出和查找，已經是O(n)的了，不見得比用向量做會快多少。

2、列表處理的一個特別好的小技巧：在列表的前面和后面各放置一個哨兵，如果把列表比作一條“繩子”，那么就相當於兩頭各放置一個手抓的地方，這樣無論列表內部會有哪些動態操作（即改變本身結構的操作，比如插入刪除，而相應的查找等不改變自己結構的操作則稱為靜態操作），都可以從一而終地從兩頭把列表給“拉”出來。好處在於，有很多需要考慮邊界情況的問題可以自動化的化為一般化的處理，也不必因為可能的刪除或插入操作不斷更新列表頭。之前做這道題並未這樣考慮的結果就是代碼里面各種判斷是否為NULL以防止邊界情況出錯，有了哨兵這樣的判斷很多時候可以一般化處理，判斷大大減少。同時也防止了越界錯誤的發生。

3、像Python那樣，總是從一而終地考慮[a, b)這樣的左閉右開區間是很有必要的，即區間左界樁總是被問題范圍所包含，而右界樁在當前狀態則不被包含。它可以大大的減少你思考問題的復雜度。遵循統一的標准也減少了犯錯的可能。

4、同樣，對於列表所對應的具體的數據結構鏈表，總是要尤其注意邊界情況。要注意的是：抽象數據類型是對數據結構更高層次的抽象。它是一種抽象定義，表現為邏輯上的特征和一些基本操作及語義，並不涉及數據的具體存儲方式。比如向量和列表。最常見的對應於這兩種抽象數據類型的具體數據類型也就是 數組 和 鏈表了。抽象有利於定義統一的借口和規范以便更一般化的歸納、使用和處理。

5、對於這道題，自己的一點小優化：
考慮到每次需要刪除的部分一定包含插入點，所以每次刪除的時候就直接定位到插入點以及它附近。
假設 插入點是k，第一次則考察k-2~k+2這五個點，
假設 有刪除操作，設刪除區段的后繼元素為m，
之后考察 m-2 ~ m+1這四個點。
重復以上兩步直到掃描這個區間不再有刪除操作。
這樣就不需要每次都掃描整個列表來判斷需不需要刪除了。
這一切都基於，列表的“局部切除手術”只可能發生在插入點附近，並且一定包含插入點。

6、另外：判等否操作比判大小關系操作效率要高；

 

【AC版代碼】

對於這道題，由於每次都要輸出 n 次，每次輸出都要遍歷一遍列表，每次都要調用I/O口，把輸出內容壓到緩存區，然后打印出來，這樣其實消耗了大量的時間。

最后，我考慮不要每操作一次就輸出一次，把幾次操作的內容存到一個字符串，到達一定的上限再輸出，然后AC了。

改進后的源代碼：

#include <stdio.h>
#include "string.h"
#include <stdlib.h>

#define Len 200000000
#define Up (Len*3/4)

typedef char ElemType;
typedef struct node
{
    ElemType data;
    struct node *next;
    struct node *front;
}List, *pList;

pList pHead = (pList)malloc(sizeof(List));
pList pTail = (pList)malloc(sizeof(List));

char ans[Len + 5];
int forprt = 0;

void creat(char *a, int n)
{
    int i;
    pList pt = pHead;

    pTail->front = pHead;
    pTail->next = NULL;
    pHead->next = pTail;
    pHead->front = NULL;
    pHead->data = pTail->data = '-';

    for (i = 0; i < n; i++)
    {
        pList pNew = (pList)malloc(sizeof(List));
        pNew->data = a[i];
        pNew->front = pt;
        pNew->next = pt->next;
        pt->next->front = pNew;
        pt->next = pNew;
        pt = pNew;
    }
}

void insert(int m, char ch)
{
    int i = -1;
    pList pt = pHead, pNew = (pList)malloc(sizeof(List));

    while (i++ < m) pt = pt->next;
    
    pNew->data = ch;
    pNew->next = pt;
    pNew->front = pt->front;
    pt->front->next = pNew;
    pt->front = pNew;
}

void del(int m)
{
    pList p1 = NULL, p2 = NULL, p3 = NULL, p4 = NULL, pt = pHead;
    pList begin = pHead, end = pTail;
    bool boo = true;
    int repeat, i = -1;

    // find position
    while (i++ < m - 2) pt = pt->next;

    //init for 'begin' and 'end'
    begin = pt; end = pt; i = 0;
    while (i++ < 4 && end->next != pTail) end = end->next;

    while (boo && pt != pTail)
    {
        boo = false; repeat = 1;
        while (pt != end)
        {
            pt = pt->next;

            if (pt->front->data == pt->data) repeat++;
            else repeat = 1;

            if (repeat == 3)
            {
                boo = true;
                if (pt->data == pt->next->data)
                {
                    repeat++;
                    pt = pt->next;
                }

                if (repeat == 3)
                {
                    p3 = pt; p2 = p3->front; p1 = p2->front;
                    p1->front->next = p3->next;
                    p3->next->front = p1->front;
                    pt = pt->next;
                    delete p1; delete p2; delete p3;
                }
                else
                {
                    p4 = pt; p3 = p4->front; p2 = p3->front; p1 = p2->front;
                    p1->front->next = p4->next;
                    p4->next->front = p1->front;
                    pt = pt->next;
                    delete p1; delete p2; delete p3; delete p4;
                }

                break;
            }
        }

        if (boo && pt != pTail)
        {
            begin = pt; i = 0;
            while (i++ < 2 && begin->front != pHead) begin = begin->front;
            end = pt; i = 0;
            if (i++ < 1 && end->next != pTail) end = end->next;
            pt = begin;
        }
    }
}

void show(bool boo)
{
    pList pt = pHead->next;

    if (pt == pTail) ans[forprt++] = '-';
    else
    {
        while (pt->next != NULL)
        {
            ans[forprt++] = pt->data;
            pt = pt->next;
        }
    }

    ans[forprt++] = '\n';

    if (forprt >= Up || boo)
    {
        ans[forprt] = '\0';
        printf("%s", ans);
        forprt = 0;
    }
}

int main(void)
{
    char a[10005];
    int n, k;
    pList pHead = NULL;

    gets(a);
    scanf("%d\n", &n);

    creat(a, strlen(a));

    for (k = 0; k < n; k++)
    {
        int m;
        char ch;

        scanf("%d ", &m);
        do
        {
            ch = getchar();
        } while (!((ch >= 'A') && (ch <= 'Z')));

        // insert ch
        insert(m, ch);  

        // delete all 3-same block, making it the right string
        del(m);

        // print the string
        show(k == n - 1 ? true : false);
    }

    return 0;
}

需要注意的點：

1、注意常量 Len 和 Up 的關系，一定不能把 Up 簡單地設置為 Len。因為如果那樣，可能某次輸出前的最后一個操作后的字符串加在原來待輸出的大字符串后面，還來不及判斷是否超過上限就已經數組下標越界了。

2、Len 已經不能再大了，再大超空間了。