{"id":373,"date":"2024-04-22T16:08:48","date_gmt":"2024-04-22T08:08:48","guid":{"rendered":"https:\/\/www.sxr666.cn\/?p=373"},"modified":"2024-07-23T20:18:36","modified_gmt":"2024-07-23T12:18:36","slug":"sjjgpta20232","status":"publish","type":"post","link":"https:\/\/www.sxr666.cn\/index.php\/2024\/04\/22\/sjjgpta20232\/","title":{"rendered":"PTA\u6570\u636e\u7ed3\u6784\u4e0e\u7a0b\u5e8f\u8bbe\u8ba1\uff08\u4e0b\uff092023\u7ec3\u4e60"},"content":{"rendered":"\n

\u6ce8\u610f\uff1a\u672c\u9875\u9762\u4e2d\u5927\u90e8\u5206\u4ee3\u7801\u90fd\u662f\u7528C++\u7f16\u5199\uff0c\u5728\u63d0\u4ea4\u65f6\u5c3d\u91cf\u5c06\u6240\u6709\u7684\u4ee3\u7801\u7684\u63d0\u4ea4\u65b9\u5f0f\u90fd\u6539\u4e3aC++\uff0c\u5426\u5219\u63d0\u4ea4\u65f6\u4f1a\u62a5\u9519\u3002<\/p>\n\n\n\n

6-1 \u987a\u5e8f\u8868\u7684\u63d2\u5165<\/strong><\/p>\n\n\n\n

void insert(int a[],int*n,int x)\n{\n    int i,t;\n    for(i=*n-1;i>=0;i--)\n    {\n        if(x>=a[i])\n        {\n        a[i+1]=x;\n        break;\n    }\n    else\n    {\n        t=a[i];\n        a[i]=x;\n        a[i+1]=t;\n    }\n}\n(*n)++;}<\/code><\/pre>\n\n\n\n
6-2 \u987a\u5e8f\u8868\u7684\u5220\u9664<\/strong><\/p>\n\n\n\n
int del(int a[], int *n, int x) {  \n    int i;  \n    for (i = 0; i < *n; i++) {  \n        if (a[i] == x) {  \n            \/\/ \u4ece\u5f53\u524d\u4f4d\u7f6e\u5f00\u59cb\uff0c\u5c06\u540e\u9762\u7684\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d  \n            for (; i < *n - 1; i++) {  \n                a[i] = a[i + 1];  \n            }  \n            \/\/ \u66f4\u65b0\u6570\u7ec4\u957f\u5ea6  \n            (*n)--;  \n            return 1; \/\/ \u627e\u5230\u4e86\u5e76\u5220\u9664\u4e86\u5143\u7d20\uff0c\u8fd4\u56de1  \n        }  \n    }  \n    return 0; \/\/ \u6ca1\u6709\u627e\u5230\u5143\u7d20\uff0c\u8fd4\u56de0  \n}<\/code><\/pre>\n\n\n\n
6-3 \u6784\u9020\u6709\u5e8f\u987a\u5e8f\u8868<\/strong><\/p>\n\n\n\n
void readArray(int a[], int n) {  \n    for (int i = 0; i < n; i++) {  \n        scanf(\"%d\", &a[i]);  \n    }  \n}  \n  \n\/\/ \u51fd\u6570\u7528\u4e8e\u5bf9\u6574\u6570\u6570\u7ec4\u8fdb\u884c\u964d\u5e8f\u6392\u5e8f\uff08\u5192\u6ce1\u6392\u5e8f\uff09  \nvoid bubbleSortDescending(int a[], int n) {  \n    int temp;  \n    int swapped;  \n    for (int i = 0; i < n - 1; i++) {  \n        swapped = 0; \/\/ \u6807\u8bb0\u8fd9\u4e00\u8f6e\u662f\u5426\u6709\u4ea4\u6362\u53d1\u751f  \n        for (int j = 0; j < n - i - 1; j++) { \/\/ \u53ea\u9700\u6bd4\u8f83\u5230\u672a\u6392\u5e8f\u90e8\u5206\u7684\u6700\u540e\u4e00\u4e2a\u5143\u7d20  \n            if (a[j] > a[j + 1]) {  \n                temp = a[j];  \n                a[j] = a[j + 1];  \n                a[j + 1] = temp;  \n                swapped = 1; \/\/ \u53d1\u751f\u4e86\u4ea4\u6362  \n            }  \n        }  \n        if (!swapped) {  \n            break; \/\/ \u5982\u679c\u6ca1\u6709\u4ea4\u6362\u53d1\u751f\uff0c\u8bf4\u660e\u6570\u7ec4\u5df2\u7ecf\u6392\u5e8f\u5b8c\u6210  \n        }  \n    }  \n}  \n  \n\/\/ \u4e3b\u5904\u7406\u51fd\u6570\uff0c\u73b0\u5728\u53ea\u8d1f\u8d23\u8c03\u7528\u4e0a\u9762\u4e24\u4e2a\u51fd\u6570  \nvoid process(int a[], int n) {  \n    readArray(a, n);  \n    bubbleSortDescending(a, n);  \n    \/\/ \u8fd9\u91cc\u53ef\u4ee5\u6dfb\u52a0\u4ee3\u7801\u4ee5\u8f93\u51fa\u6392\u5e8f\u540e\u7684\u6570\u7ec4\u6216\u5176\u4ed6\u540e\u7eed\u5904\u7406  \n}<\/code><\/pre>\n\n\n\n
6-4 \u5feb\u901f\u6c42\u6700\u5927\u6700\u5c0f\u503c\uff08\u5206\u6cbb\u6cd5\uff09<\/strong><\/p>\n\n\n\n
int find_extreme(int *a, int m, int n, int (*compare)(int, int)) {\n    if (m == n) return a[m]; \/\/ \u53ea\u6709\u4e00\u4e2a\u5143\u7d20\u65f6\u76f4\u63a5\u8fd4\u56de  \n    \n    int mid = (m + n) \/ 2;  \n    \n    int left = find_extreme(a, m, mid, compare);  \n    int right = find_extreme(a, mid + 1, n, compare);  \n    \n    return compare(left, right) ? right : left;  \n}\n\/\/ \u6bd4\u8f83\u51fd\u6570\nint greater_than(int a, int b) {\n    return a > b;\n}\n\nint less_than(int a, int b) {\n    return a < b;\n}\nint max(int *a, int m, int n) {\n    return find_extreme(a, m, n, &less_than);\n}\n\nint min(int *a, int m, int n) {\n    return find_extreme(a, m, n, &greater_than);\n}<\/code><\/pre>\n\n\n\n
6-5 \u6700\u5927\u5b50\u6bb5\u548c\uff08\u5206\u6cbb\u6cd5\uff09<\/strong><\/p>\n\n\n\n
int maxsubsum(int *a,int left,int right){\n    int sum=a[0],maxx=a[0];for(left=1;left<=right;left++){sum=sum>0?sum:0;sum+=a[left];maxx=maxx>sum?maxx:sum;}return maxx;\n}<\/code><\/pre>\n\n\n\n
6-6 \u68cb\u76d8\u8986\u76d6\u95ee\u9898\uff08\u5206\u6cbb\u6cd5\uff09<\/strong><\/strong><\/p>\n\n\n\n
void ChessBoard(int tr, int tc, int dr, int dc, int size){\n    int sxr,ssr;\n    if(size==1) return;\/\/\u8df3\u51fa\u5faa\u73af\n    sxr=++num;\n    ssr=size\/2;\n    \n    if(dr<(tr+ssr)&&dc<(tc+ssr)){\/\/\u5728\u5de6\u4e0a\u89d2\n        ChessBoard(tr,tc,dr,dc,ssr);\n    }\n    else{\n        board[tr+ssr-1][tc+ssr-1]=sxr;\n        ChessBoard(tr,tc,tr+ssr-1,tc+ssr-1,ssr);\n    }\n    \n    if(dr<(tr+ssr)&&dc>=(tc+ssr)){\/\/\u5728\u53f3\u4e0a\u89d2\n        ChessBoard(tr,tc+ssr,dr,dc,ssr);\n    }\n    else{\n        board[tr+ssr-1][tc+ssr]=sxr;\n        ChessBoard(tr,tc+ssr,tr+ssr-1,tc+ssr,ssr);\n    }\n    \n    if(dr>=(tr+ssr)&&dc<(tc+ssr)){\/\/\u5728\u5de6\u4e0b\u89d2\n        ChessBoard(tr+ssr,tc,dr,dc,ssr);\n    }\n    else{\n        board[tr+ssr][tc+ssr-1]=sxr;\n        ChessBoard(tr+ssr,tc,tr+ssr,tc+ssr-1,ssr);\n    }\n\n    if(dr>=(tr+ssr)&&dc>=(tc+ssr)){\/\/\u5728\u53f3\u4e0b\u89d2\n        ChessBoard(tr+ssr,tc+ssr,dr,dc,ssr);\n    }\n    else{\n        board[tr+ssr][tc+ssr]=sxr;\n        ChessBoard(tr+ssr,tc+ssr,tr+ssr,tc+ssr,ssr);\n    }\n}<\/code><\/pre>\n\n\n\n
6-7 \u4e24\u4f4d\u6570\u5408\u5e76<\/strong><\/p>\n\n\n\n
void swap(int a, int b, int *c) {  \n    \/\/ \u786e\u4fdda\u548cb\u90fd\u662f\u4e24\u4f4d\u6570  \n    if (a < 10 || a > 99 || b < 10 || b > 99) {  \n        \/\/ \u5904\u7406\u9519\u8bef\u60c5\u51b5\uff0c\u4f8b\u5982\u8bbe\u7f6ec\u4e3a\u67d0\u4e2a\u7279\u6b8a\u503c\u6216\u8fd4\u56de\u9519\u8bef\u4ee3\u7801  \n        *c = -1; \/\/ \u793a\u4f8b\uff1a\u5c06c\u8bbe\u7f6e\u4e3a-1\u8868\u793a\u9519\u8bef  \n        return;  \n    }  \n  \n    \/\/ \u63d0\u53d6a\u548cb\u7684\u5341\u4f4d\u6570\u548c\u4e2a\u4f4d\u6570  \n    int tensA = a \/ 10;  \n    int onesA = a % 10;  \n    int tensB = b \/ 10;  \n    int onesB = b % 10;  \n  \n    \/\/ \u91cd\u65b0\u7ec4\u5408\u6570\u5b57\u5e76\u5b58\u50a8\u5728c\u6307\u5411\u7684\u4f4d\u7f6e  \n    *c = 1000 * tensB + 100 * tensA + 10 * onesB + onesA;  \n}<\/code><\/pre>\n\n\n\n
6-8 \u7528\u6307\u9488\u64cd\u4f5c\u6570\u7ec4\u8f93\u5165\u8f93\u51fa\u5143\u7d20(\u6307\u9488\u505a\u5f62\u53c2\uff09<\/strong><\/p>\n\n\n\n
void fun(int *b, int n) {  \n    for (int i = 0; i < n; i++) {  \n        int *temp = b + i; \/\/ \u4f7f\u7528\u4e34\u65f6\u6307\u9488\u6765\u6307\u5411\u5f53\u524d\u8981\u8bfb\u53d6\u6216\u6253\u5370\u7684\u5143\u7d20  \n        scanf(\"%d\", temp); \/\/ \u8bfb\u53d6\u8f93\u5165\u5230\u5f53\u524d\u4f4d\u7f6e  \n        if (i < n - 1) {  \n            printf(\"%d \", *temp); \/\/ \u5982\u679c\u4e0d\u662f\u6700\u540e\u4e00\u4e2a\u5143\u7d20\uff0c\u6253\u5370\u5e76\u52a0\u4e0a\u7a7a\u683c  \n        } else {  \n            printf(\"%d\", *temp); \/\/ \u5982\u679c\u662f\u6700\u540e\u4e00\u4e2a\u5143\u7d20\uff0c\u53ea\u6253\u5370\u5143\u7d20\u503c  \n        }  \n    }  \n}<\/code><\/pre>\n\n\n\n
6-9 \u7ed3\u6784\u4f53\u6307\u9488\u5f62\u5f0f\u8f93\u51fa<\/strong><\/p>\n\n\n\n
void output(RECORD *p, int n) {  \n    while (n--) {  \n        printf(\"%s,%d\\n\", p->no, p->score);  \n        p--; \/\/ \u79fb\u52a8\u5230\u524d\u4e00\u4e2a\u5143\u7d20  \n    }  \n}<\/code><\/pre>\n\n\n\n
6-10 \u64cd\u4f5c\u6307\u9488\u4e32\u63a5\u4e24\u4e2a\u7ed3\u70b9<\/strong><\/p>\n\n\n\n
ptr Connect(int x1, int x2) {  \n    \/\/ \u5206\u914d\u7b2c\u4e00\u4e2a\u8282\u70b9\u7684\u5185\u5b58  \n    ptr first = (ptr)malloc(sizeof(snode));  \n    if (first == NULL) {  \n        \/\/ \u5904\u7406\u5185\u5b58\u5206\u914d\u5931\u8d25\u7684\u60c5\u51b5  \n        return NULL;  \n    }  \n      \n    \/\/ \u4e3a\u7b2c\u4e00\u4e2a\u8282\u70b9\u8d4b\u503c  \n    first->data = x1;  \n      \n    \/\/ \u5206\u914d\u7b2c\u4e8c\u4e2a\u8282\u70b9\u7684\u5185\u5b58\u5e76\u76f4\u63a5\u94fe\u63a5\u5230\u7b2c\u4e00\u4e2a\u8282\u70b9\u7684next  \n    first->next = (ptr)malloc(sizeof(snode));  \n    if (first->next == NULL) {  \n        \/\/ \u5982\u679c\u7b2c\u4e8c\u4e2a\u8282\u70b9\u5185\u5b58\u5206\u914d\u5931\u8d25\uff0c\u91ca\u653e\u7b2c\u4e00\u4e2a\u8282\u70b9\u5e76\u8fd4\u56deNULL  \n        free(first);  \n        return NULL;  \n    }  \n      \n    \/\/ \u4e3a\u7b2c\u4e8c\u4e2a\u8282\u70b9\u8d4b\u503c  \n    first->next->data = x2;  \n      \n    \/\/ \u8bbe\u7f6e\u7b2c\u4e8c\u4e2a\u8282\u70b9\u7684next\u4e3aNULL\uff0c\u8868\u793a\u94fe\u8868\u7ed3\u675f  \n    first->next->next = NULL;  \n      \n    \/\/ \u8fd4\u56de\u94fe\u8868\u7684\u5934\u8282\u70b9  \n    return first;  \n}<\/code><\/pre>\n\n\n\n
6-11 \u64cd\u4f5c\u6307\u9488\u5220\u9664\u4e09\u4e2a\u5df2\u4e32\u63a5\u7ed3\u70b9\u4e2d\u7684\u7b2c\u4e8c\u4e2a\u7ed3\u70b9<\/strong><\/p>\n\n\n\n
ptr destroy(ptr p1) {  \n    if (p1 != NULL && p1->next != NULL) {  \n        ptr to_free = p1->next;  \n        p1->next = to_free->next;  \n        free(to_free);  \n    }  \n    return p1;  \n}<\/code><\/pre>\n\n\n\n
6-12 \u8868\u5934\u63d2\u5165\u6cd5\u6784\u9020\u94fe\u8868<\/strong><\/p>\n\n\n\n
ptr creat() {  \n    ptr head = NULL, p, prev = NULL;  \n    int x;  \n  \n    \/\/ \u8bfb\u53d6\u7b2c\u4e00\u4e2a\u6570\u636e\u9879  \n    scanf(\"%d\", &x);  \n      \n    \/\/ \u5f53\u7528\u6237\u8f93\u5165\u975e0\u503c\u65f6\uff0c\u521b\u5efa\u65b0\u8282\u70b9\u5e76\u6dfb\u52a0\u5230\u94fe\u8868\u4e2d  \n    while (x != 0) {  \n        p = (ptr)malloc(sizeof(snode));  \n        if (p == NULL) {  \n            \/\/ \u5904\u7406\u5185\u5b58\u5206\u914d\u5931\u8d25\u7684\u60c5\u51b5  \n            \/\/ ...  \n            return NULL;  \n        }  \n        p->data = x;  \n        p->next = head; \/\/ \u65b0\u8282\u70b9\u6307\u5411\u5f53\u524d\u5934\u8282\u70b9  \n        head = p; \/\/ \u66f4\u65b0\u5934\u8282\u70b9\u4e3a\u65b0\u8282\u70b9  \n        prev = p; \/\/ \u66f4\u65b0prev\u4e3a\u5f53\u524d\u8282\u70b9\uff0c\u4ee5\u4fbf\u5728\u4e0b\u6b21\u5faa\u73af\u4e2d\u5904\u7406  \n        scanf(\"%d\", &x); \/\/ \u8bfb\u53d6\u4e0b\u4e00\u4e2a\u6570\u636e\u9879  \n    }  \n  \n    return head;  \n}\nvoid output(ptr p) {  \n    while (p != NULL) {  \n        printf(\"%d \", p->data);  \n        p = p->next; \/\/ \u79fb\u52a8\u5230\u4e0b\u4e00\u4e2a\u8282\u70b9  \n    }  \n    printf(\"\\n\"); \/\/ \u8f93\u51fa\u6362\u884c\u7b26\u4ee5\u6539\u5584\u53ef\u8bfb\u6027  \n}<\/code><\/pre>\n\n\n\n
6-13 \u8868\u5c3e\u63d2\u5165\u6cd5\u6784\u9020\u94fe\u8868<\/strong><\/p>\n\n\n\n
ptr creat() {  \n    int x;  \n    ptr head = NULL, last = NULL;  \n  \n    \/\/ \u8bfb\u53d6\u7b2c\u4e00\u4e2a\u5143\u7d20  \n    scanf(\"%d\", &x);  \n  \n    \/\/ \u5982\u679c\u8f93\u5165\u7684\u662f0\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u7a7a\u94fe\u8868  \n    if (x == 0) return head;  \n  \n    \/\/ \u521b\u5efa\u7b2c\u4e00\u4e2a\u8282\u70b9  \n    head = (ptr)malloc(sizeof(snode));  \n    if (head == NULL) {  \n        \/\/ \u5904\u7406\u5185\u5b58\u5206\u914d\u5931\u8d25\u7684\u60c5\u51b5  \n        return NULL;  \n    }  \n    head->data = x;  \n    head->next = NULL;  \n    last = head; \/\/ last\u6307\u5411\u94fe\u8868\u7684\u6700\u540e\u4e00\u4e2a\u8282\u70b9  \n  \n    \/\/ \u5faa\u73af\u8bfb\u53d6\u5269\u4f59\u5143\u7d20\uff0c\u5e76\u521b\u5efa\u65b0\u7684\u8282\u70b9  \n    while (1) {  \n        scanf(\"%d\", &x);  \n        if (x == 0) break; \/\/ \u5982\u679c\u8f93\u5165\u7684\u662f0\uff0c\u5219\u7ed3\u675f\u5faa\u73af  \n  \n        \/\/ \u521b\u5efa\u65b0\u8282\u70b9  \n        ptr p = (ptr)malloc(sizeof(snode));  \n        if (p == NULL) {  \n            \/\/ \u5904\u7406\u5185\u5b58\u5206\u914d\u5931\u8d25\u7684\u60c5\u51b5  \n            \/\/ \u91ca\u653e\u5df2\u5206\u914d\u7684\u8282\u70b9\u5185\u5b58\uff08\u6b64\u5904\u9700\u8981\u6dfb\u52a0\u989d\u5916\u7684\u903b\u8f91\u6765\u904d\u5386\u94fe\u8868\u5e76\u91ca\u653e\uff09  \n            return NULL;  \n        }  \n        p->data = x;  \n        p->next = NULL;  \n  \n        \/\/ \u5c06\u65b0\u8282\u70b9\u6dfb\u52a0\u5230\u94fe\u8868\u7684\u672b\u5c3e  \n        last->next = p;  \n        last = p; \/\/ \u66f4\u65b0last\u6307\u9488  \n    }  \n  \n    return head;  \n}\nvoid output(ptr p) {  \n    while (p != NULL) {  \n        printf(\"%d \", p->data);  \n        p = p->next; \/\/ \u79fb\u52a8\u5230\u4e0b\u4e00\u4e2a\u8282\u70b9  \n    }  \n    printf(\"\\n\"); \/\/ \u8f93\u51fa\u6362\u884c\u7b26\u4ee5\u6539\u5584\u53ef\u8bfb\u6027  \n}<\/code><\/pre>\n\n\n\n
6-14 \u5bfb\u627e\u94fe\u8868\u5143\u7d20\u7684\u524d\u9a71\u7ed3\u70b9<\/strong><\/p>\n\n\n\n
ptr pre(ptr h, int x) {  \n    ptr current = h, prev = NULL;  \n  \n    \/\/ \u904d\u5386\u94fe\u8868\uff0c\u76f4\u5230\u627e\u5230\u503c\u4e3ax\u7684\u8282\u70b9\u6216\u5230\u8fbe\u94fe\u8868\u672b\u5c3e  \n    while (current != NULL && current->data != x) {  \n        prev = current;  \n        current = current->next;  \n    }  \n  \n    \/\/ \u5982\u679c\u627e\u5230\u4e86\u503c\u4e3ax\u7684\u8282\u70b9\uff0c\u5219\u8fd4\u56de\u5b83\u7684\u524d\u4e00\u4e2a\u8282\u70b9\uff1b\u5426\u5219\u8fd4\u56deNULL  \n    if (current != NULL && current->data == x) {  \n        return prev;  \n    }  \n      \n    return NULL;  \n}<\/code><\/pre>\n\n\n\n
6-15 \u6c42\u94fe\u8868\u7684\u5012\u6570\u7b2cm\u4e2a\u5143\u7d20<\/strong><\/p>\n\n\n\n
ElementType Find(List L, int m) {  \n    struct Node *current;  \n    int count = 0;  \n  \n    \/\/ \u7b2c\u4e00\u6b21\u904d\u5386\uff0c\u8ba1\u7b97\u94fe\u8868\u957f\u5ea6\uff0c\u540c\u65f6\u68c0\u67e5\u662f\u5426\u5c0f\u4e8em  \n    current = L->Next;  \n    while (current != NULL) {  \n        count++;  \n        if (count < m) {  \n            current = current->Next;  \n        } else {  \n            break; \/\/ \u5982\u679c\u94fe\u8868\u957f\u5ea6\u5927\u4e8e\u6216\u7b49\u4e8em\uff0c\u5219\u9000\u51fa\u5faa\u73af  \n        }  \n    }  \n  \n    \/\/ \u5982\u679c\u94fe\u8868\u957f\u5ea6\u5c0f\u4e8em\uff0c\u5219\u8fd4\u56de\u9519\u8bef  \n    if (count < m) {  \n        return ERROR;  \n    }  \n  \n    \/\/ \u7b2c\u4e8c\u6b21\u904d\u5386\uff0c\u627e\u5230\u7b2cm\u4e2a\u8282\u70b9\u7684\u6570\u636e  \n    current = L->Next;  \n    for (int i = 0; i < m - 1; i++) { \/\/ \u6ce8\u610f\u8fd9\u91cc\u53ea\u9700\u8981\u904d\u5386\u5230\u7b2cm-1\u4e2a\u8282\u70b9  \n        current = current->Next;  \n    }  \n  \n    \/\/ \u8fd4\u56de\u7b2cm\u4e2a\u8282\u70b9\u7684\u6570\u636e  \n    return current->Data;  \n}<\/code><\/pre>\n\n\n\n
6-16 \u6784\u9020\u6709\u5e8f\u94fe\u8868<\/strong><\/p>\n\n\n\n
ptr creat() {  \n    ptr head = NULL;  \/\/ \u94fe\u8868\u7684\u5934\u6307\u9488  \n    ptr tail = NULL;  \/\/ \u94fe\u8868\u7684\u5c3e\u6307\u9488  \n    ptr newNode;      \/\/ \u65b0\u8282\u70b9\u7684\u6307\u9488  \n    int value;  \n  \n    \/\/ \u5faa\u73af\u8bfb\u53d6\u7528\u6237\u8f93\u5165\uff0c\u76f4\u5230\u8f93\u51650  \n    while (1) {  \n        scanf(\"%d\", &value);  \n        if (value == 0) {  \n            break;  \n        }  \n  \n        \/\/ \u521b\u5efa\u65b0\u8282\u70b9  \n        newNode = (ptr)malloc(sizeof(snode));  \n        newNode->data = value;  \n        newNode->next = NULL;  \n  \n        \/\/ \u63d2\u5165\u65b0\u8282\u70b9\u5230\u6709\u5e8f\u94fe\u8868\u4e2d  \n        if (head == NULL || value <= head->data) {  \n            \/\/ \u65b0\u8282\u70b9\u6210\u4e3a\u65b0\u7684\u5934\u8282\u70b9\u6216\u63d2\u5165\u5230\u5934\u90e8  \n            newNode->next = head;  \n            head = newNode;  \n            if (tail == NULL) {  \n                tail = newNode;  \n            }  \n        } else {  \n            \/\/ \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e  \n            ptr current = head;  \n            while (current->next != NULL && current->next->data < value) {  \n                current = current->next;  \n            }  \n            \/\/ \u63d2\u5165\u65b0\u8282\u70b9  \n            newNode->next = current->next;  \n            current->next = newNode;  \n            \/\/ \u66f4\u65b0\u5c3e\u6307\u9488\uff0c\u5982\u679c\u5fc5\u8981  \n            if (current == tail) {  \n                tail = newNode;  \n            }  \n        }  \n    }  \n  \n    return head;  \n}  \n  \n\/\/ \u8f93\u51fa\u94fe\u8868\u5143\u7d20  \nvoid output(ptr p) {  \n    ptr current = p;  \n    while (current != NULL) {  \n        printf(\"%d \", current->data);  \n        current = current->next;  \n    }  \n    printf(\"\\n\");  \n} <\/code><\/pre>\n\n\n\n
6-17 \u52a0\u5934\u94fe\u8868\u7684\u63d2\u5165\u548c\u5220\u9664<\/strong><\/p>\n\n\n\n
void ins(ptr h,int x){\n    ptr newNode,a,b;\n    newNode=(ptr)malloc(sizeof(snode));\n    newNode->data=x;\n    ptr sxr = h;  \n    \n    while (sxr->next != NULL && sxr->next->data < x) {  \n        sxr = sxr->next;  \n    }  \n    \/\/ \u63d2\u5165\u65b0\u8282\u70b9  \n    newNode->next = sxr->next;  \n    sxr->next = newNode;  \n    return;\n}\n\nvoid del(ptr h, int x){\n    ptr sxr = h, prev = NULL;  \n    while(sxr != NULL && sxr->data != x){  \n        prev = sxr; \/\/ \u4fdd\u5b58\u5f53\u524d\u8282\u70b9\u7684\u4e0a\u4e00\u4e2a\u8282\u70b9  \n        sxr = sxr->next;  \n    }  \n    if(sxr == NULL){  \n        printf(\"no %d\\n\", x);  \n        return;  \n    }  \n    if(prev == NULL){ \/\/ \u5982\u679c\u8981\u5220\u9664\u7684\u8282\u70b9\u662f\u5934\u8282\u70b9  \n        h = sxr->next;  \n    } else {  \n        prev->next = sxr->next; \/\/ \u5426\u5219\u66f4\u65b0\u4e0a\u4e00\u4e2a\u8282\u70b9\u7684 next \u6307\u9488  \n    }  \n    free(sxr); \/\/ \u91ca\u653e\u88ab\u5220\u9664\u8282\u70b9\u7684\u5185\u5b58  \n    return;  \n}<\/code><\/pre>\n\n\n\n
6-18 \u5faa\u73af\u5355\u94fe\u8868\u7684\u8ffd\u52a0<\/strong><\/p>\n\n\n\n
void AppendP(struct Node **rear,struct Node *p){\n    if((*rear)==NULL){\n        p->next=p;\n        (*rear)=p;\n    }\n    else{\n        p->next=(*rear)->next;\n        (*rear)->next=p;\n        (*rear)=p;\n    }\n    return;\n}<\/code><\/pre>\n\n\n\n
6-19 \u5faa\u73af\u53cc\u94fe\u8868\u63d2\u5165\u64cd\u4f5c<\/strong><\/p>\n\n\n\n
Status ListInsert_DuL(DuLinkList &L, int i, ElemType e){\n    DuLinkList sxr=L;\n    DuLinkList rxs;\n    rxs=(DuLinkList)malloc(sizeof(DuLNode));\n    rxs->data=e;\n    for(int j=0;j<i-1;j++){\n        sxr=sxr->next;\n    }\n    rxs->next=sxr->next;\n    sxr->next->prior=rxs;\n    sxr->next=rxs;\n    rxs->prior=sxr;\n    return 0;\n}<\/code><\/pre>\n\n\n\n
6-20 \u5faa\u73af\u53cc\u94fe\u8868\u5220\u9664\u64cd\u4f5c<\/strong><\/p>\n\n\n\n
int ListDelete_DuL(DuLinkList &L, int i){\n    DuLinkList sxr=L,rxs,rsx;\n    for(int j=0;j<i-1;j++){\n        sxr=sxr->next;\n    }\n    rsx=sxr->next;\n    sxr->next=rsx->next;\n    rsx->prior=sxr;\n    free(rsx);\n    return 0;\n}<\/code><\/pre>\n\n\n\n
6-21 \u521b\u5efa\u5faa\u73af\u53cc\u94fe\u8868<\/strong><\/p>\n\n\n\n
void CreateDuList(DuLinkList &L,int n){\n    L=(DuLinkList)malloc(sizeof(DuLNode));\n    L->prior=L;\n    L->next=L;\n    DuLinkList p,en=L;\n    for(int i=0;i<n;i++){\n        p=(DuLinkList)malloc(sizeof(DuLNode));\n        cin>>p->data;\n        p->prior=en;\n        p->next=L;\n        en->next=p;\n        en=en->next;\n        L->prior=en;\n    }\n    return;\n\n}<\/code><\/pre>\n\n\n\n
6-22 \u6709\u5e8f\u7a00\u758f\u591a\u9879\u5f0f\u6c42\u548c<\/strong><\/p>\n\n\n\n
ptr add(ptr ha,ptr hb){\n    ptr h,h1=ha->next,h2=hb->next,p,end;\n    h=malloc(sizeof(node));\n    end=h;\n    while(h1!=NULL&&h2!=NULL){\n        p=malloc(sizeof(node));\n        if(h1->exp<h2->exp){\n            p->ceof=h1->ceof;\n            p->exp=h1->exp;\n            p->next=NULL;\n            h1=h1->next;\n            end->next=p;\n            end=p;\n        }\n        else if(h1->exp>h2->exp){\n            p->ceof=h2->ceof;\n            p->exp=h2->exp;\n            p->next=NULL;\n            h2=h2->next;\n            end->next=p;\n            end=p;\n        }\n        else{\n            if((h1->ceof+h2->ceof)!=0){\n                p->ceof=h1->ceof+h2->ceof;\n                p->exp=h1->exp;\n                p->next=NULL;\n                h1=h1->next;\n                h2=h2->next;\n                end->next=p;\n                end=p;\n            }\n            else{\n                h1=h1->next;\n                h2=h2->next;\n            }\n        }\n    }\n    while(h1!=NULL){\n        p=malloc(sizeof(node));\n        p->ceof=h1->ceof;\n        p->exp=h1->exp;\n        p->next=NULL;\n        h1=h1->next;\n        end->next=p;\n        end=p;\n    }\n    while(h2!=NULL){\n        p=malloc(sizeof(node));\n        p->ceof=h2->ceof;\n        p->exp=h2->exp;\n        p->next=NULL;\n        h2=h2->next;\n        end->next=p;\n        end=p;\n    }\n    return h;\n}<\/code><\/pre>\n\n\n\n
6-23 \u7b80\u5355\u8868\u8fbe\u5f0f\u6c42\u503c<\/strong><\/p>\n\n\n\n
int cal( char a[] )\n{\n    int i=0,x=0,z=0,s;\n    char sxr;\n    while(a[i]!='=')\n    {\n        while(a[i]>='0'&&a[i]<='9')\n        {\n            x=x*10+a[i]-'0';\n            i++;\n        }\n        sxr=a[i++];\n        while(a[i]>='0'&&a[i]<='9')\n        {\n            z=z*10+a[i]-'0';\n            i++;\n        }\n    }\n    switch(sxr)\n    {\n        case '+':s=x+z;break;\n        case '-':s=x-z;break;\n        case '*':s=x*z;break;\n        case '\/':s=x\/z;\n    }\n    return s;\n}<\/code><\/pre>\n\n\n\n
6-24 \u62ec\u53f7\u5339\u914d\u5224\u65ad<\/strong><\/p>\n\n\n\n
typedef struct {  \n    char data[1000];  \n    int top;  \n} Stack;  \n  \n\/\/ \u521d\u59cb\u5316\u6808  \nvoid initStack(Stack *s) {  \n    s->top = -1;  \n}  \n  \n\/\/ \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a  \nint isEmpty(Stack *s) {  \n    return s->top == -1;  \n}  \n  \n\/\/ \u5165\u6808  \nvoid push(Stack *s, char item) {  \n    if (s->top < 999) {  \n        s->data[++s->top] = item;  \n    } else {  \n        printf(\"Stack is full\\n\");  \n        exit(1);  \n    }  \n}  \n  \n\/\/ \u51fa\u6808  \nchar pop(Stack *s) {  \n    if (!isEmpty(s)) {  \n        return s->data[s->top--];  \n    } else {  \n        printf(\"Stack is empty\\n\");  \n        exit(1);  \n    }  \n}  \n  \n\/\/ \u68c0\u67e5\u6808\u9876\u5143\u7d20  \nchar peek(Stack *s) {  \n    if (!isEmpty(s)) {  \n        return s->data[s->top];  \n    } else {  \n        printf(\"Stack is empty\\n\");  \n        exit(1);  \n    }  \n}  \n  \n\/\/ \u5339\u914d\u51fd\u6570  \nint match(char *exp) {  \n    Stack s;  \n    initStack(&s);  \n    char *p = exp;  \n    while (*p) {  \n        switch (*p) {  \n            case '(':  \n            case '[':  \n            case '{':  \n                push(&s, *p);  \n                break;  \n            case ')':  \n                if (!isEmpty(&s) && peek(&s) == '(') {  \n                    pop(&s);  \n                } else {  \n                    return 0; \/\/ \u4e0d\u5339\u914d  \n                }  \n                break;  \n            case ']':  \n                if (!isEmpty(&s) && peek(&s) == '[') {  \n                    pop(&s);  \n                } else {  \n                    return 0; \/\/ \u4e0d\u5339\u914d  \n                }  \n                break;  \n            case '}':  \n                if (!isEmpty(&s) && peek(&s) == '{') {  \n                    pop(&s);  \n                } else {  \n                    return 0; \/\/ \u4e0d\u5339\u914d  \n                }  \n                break;  \n            default:  \n                \/\/ \u5982\u679c\u662f\u5176\u4ed6\u5b57\u7b26\uff0c\u5219\u7ee7\u7eed\u68c0\u67e5\u4e0b\u4e00\u4e2a\u5b57\u7b26  \n                break;  \n        }  \n        p++;  \n    }  \n    return isEmpty(&s); \/\/ \u5982\u679c\u6808\u4e3a\u7a7a\uff0c\u8bf4\u660e\u6240\u6709\u62ec\u53f7\u90fd\u5339\u914d\uff0c\u8fd4\u56de1\uff1b\u5426\u5219\u8fd4\u56de0  \n} <\/code><\/pre>\n\n\n\n
6-25 \u8868\u8fbe\u5f0f\u6c42\u503c-\u6df7\u5408\u56db\u5219\u8fd0\u7b97<\/strong><\/p>\n\n\n\n
int order(char a, char b)\n{\n int ar=0,br=0;\n if(a=='*'||a=='\/') ar=2;\n else \n     if(a=='+'||a=='-') ar=1;\n if(b=='*'||b=='\/') br=2;\n else \n     if(b=='+'||b=='-') br=1;\n if(b=='=')br=-1;\n if(ar>=br) return 1;\n else return 0;\n}\ndouble calcu(double a, double b ,char c)\n{\n switch(c)\n {\n  case '+':return a+b;\n  case '-':return a-b;\n  case '*':return a*b;\n  case '\/':return a\/b;\n }\n return 0;\n}\n\nvoid insta(char str[],double nust[],char opst[])\n{\n int m=0, n=0,i=0;\n double tenu=0;\n for(;str[i]!='\\0';i++)\n {\n  if(str[i]<='9'&&str[i]>='0')\n   tenu=tenu*10+str[i]-'0';\n  else\n      if(str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='\/'||str[i]=='('||str[i]==')'||str[i]=='=')\n      {\n       nust[m++]=tenu;\n       tenu=0;\n       opst[n++]=str[i];\n      }\n }\n}\n\nint cal(char str[])\n{\n    double nust[20];\n    char opst[20];\n insta(str,nust,opst);\n while(opst[0]!='=')\n {\n  int i=0;\n  if(order(opst[i],opst[i+1]))\n  {\n   double a=calcu(nust[i],nust[i+1],opst[i]);\n   nust[i]=a;\n   for(int w=i+1;nust[w]!=0;w++)\n    nust[w]=nust[w+1];\n   for(int w=i;opst[w]!='\\0';w++)\n    opst[w]=opst[w+1];\n  }\n  else\n  {\n   i++;\n   double a=calcu(nust[i],nust[i+1],opst[i]);\n   nust[i]=a;\n   for(int w=i+1;nust[w]!=0;w++)\n    nust[w]=nust[w+1];\n   for(int w=i;opst[w]!='\\0';w++)\n    opst[w]=opst[w+1];\n  }\n }\n    return nust[0];\n}\n<\/code><\/pre>\n\n\n\n
6-26 \u77e9\u9635\u8f6c\u7a00\u758f\u77e9\u9635<\/strong><\/p>\n\n\n\n
int create_mat(int (*d)[N],int m,int n,elem *a){\n    int i,j,k=0;\n    for(i=0;i<m;i++){\n        for(j=0;j<n;j++){\n            if(d[i][j]!=0){\n                a[k].row=i;\n                a[k].col=j;\n                a[k].val=d[i][j];\n                k++;\n            }\n        }\n    }\n    return k;\n}\n\nvoid show_mat(elem *a,int n){\n    int i;\n    for(i=0;i<n;i++){\n        printf(\"%d %d %d\\n\",a[i].row,a[i].col,a[i].val);\n    }\n    return;\n}<\/code><\/pre>\n\n\n\n
6-27 \u7a00\u758f\u77e9\u9635\u8f6c\u7f6e<\/strong><\/p>\n\n\n\n
void trans_mat(elem a[],int n,elem b[]){\n    int i,k=0;\n    for(i=0;i<n;i++){\n        b[k].row=a[i].col;\n        b[k].col=a[i].row;\n        b[k].val=a[i].val;\n        k++;\n    }\n    return;\n}\n\nvoid show_mat(elem a[],int n){\n    int i,j,sxr[6][6]={0};\n    for(i=0;i<n;i++){\n        sxr[a[i].row][a[i].col]=a[i].val;\n    }\n    for(i=0;i<N;i++){\n        for(j=0;j<N;j++){\n            if(sxr[i][j]!=0){\n                printf(\"%d %d %d\\n\",i,j,sxr[i][j]);\n            }\n        }\n    }\n    return;\n}<\/code><\/pre>\n\n\n\n
6-28 \u7a00\u758f\u77e9\u9635\u6c42\u548c<\/strong><\/p>\n\n\n\n
int add_mat(elem a[],int t1,elem b[],int t2, elem c[]){\n    int i,j,k=0,sxr[M][N]={0},s;\n    for(i=0;i<t1;i++){\n        for(j=0;j<t2;j++){\n            if(a[i].row==b[j].row&&a[i].col==b[j].col&&(a[i].val+b[j].val)!=0){\n                sxr[a[i].row][a[i].col]=a[i].val+b[j].val;\n            }\n        }\n    }\n    for(i=0;i<t1;i++){\n        for(j=0;j<t2;j++){\n            if(a[i].row==b[j].row&&a[i].col==b[j].col){\n                j=999;\n            }\n        }\n        if(j==t2){\n            sxr[a[i].row][a[i].col]=a[i].val;\n        }\n    }\n    \n    for(j=0;j<t2;j++){\n        for(i=0;i<t1;i++){\n            if(a[i].row==b[j].row&&a[i].col==b[j].col){\n                i=999;\n            }\n        }\n        if(i==t1){\n            sxr[b[j].row][b[j].col]=b[j].val;\n        }\n    }\n    for(i=0;i<M;i++){\n        for(j=0;j<N;j++){\n            if(sxr[i][j]!=0){\n                c[k].row=i;\n                c[k].col=j;\n                c[k].val=sxr[i][j];\n                k++;\n            }\n        }\n    }\n    return k;\n}<\/code><\/pre>\n\n\n\n
6-29 \u4e8c\u53c9\u6811\u7684\u904d\u5386<\/strong><\/p>\n\n\n\n
Bptr creat(){\n    Bptr a,b,c;\n    a=(Bptr)malloc(sizeof(Bnode));\n    b=(Bptr)malloc(sizeof(Bnode));\n    c=(Bptr)malloc(sizeof(Bnode));\n    scanf(\"%d%d%d\",&a->data,&b->data,&c->data);\n    a->Lson=b;\n    a->Rson=c;\n    b->Lson=NULL;\n    b->Rson=NULL;\n    c->Lson=NULL;\n    c->Rson=NULL;\n    return a;\n}\nvoid preorder(Bptr p){\n    printf(\"%d \",p->data);\n    printf(\"%d \",p->Lson->data);\n    printf(\"%d \",p->Rson->data);\n    return;\n}\nvoid inorder(Bptr p){\n    printf(\"%d \",p->Lson->data);\n    printf(\"%d \",p->data);\n    printf(\"%d \",p->Rson->data);\n    return;\n}\nvoid postorder(Bptr p){\n    printf(\"%d \",p->Lson->data);\n    printf(\"%d \",p->Rson->data);\n    printf(\"%d \",p->data);\n    return;\n}<\/code><\/pre>\n\n\n\n
6-30 \u8ba1\u7b97\u4e8c\u53c9\u6811\u7684\u53f6\u5b50\u6570<\/strong><\/p>\n\n\n\n
int num(Bptr p) {  \n    if (p == NULL) {  \n        \/\/ \u5982\u679c\u8282\u70b9\u4e3a\u7a7a\uff08\u5230\u8fbe\u53f6\u5b50\u7684\u4e0b\u65b9\uff09\uff0c\u5219\u8fd4\u56de0  \n        return 0;  \n    }  \n    if (p->Lson == NULL && p->Rson == NULL) {  \n        \/\/ \u5982\u679c\u8282\u70b9\u662f\u53f6\u5b50\u8282\u70b9\uff08\u6ca1\u6709\u5de6\u53f3\u5b50\u8282\u70b9\uff09\uff0c\u5219\u8fd4\u56de1  \n        return 1;  \n    }  \n    \/\/ \u5426\u5219\uff0c\u9012\u5f52\u5730\u8ba1\u7b97\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u7684\u53f6\u5b50\u8282\u70b9\u6570\uff0c\u5e76\u8fd4\u56de\u5b83\u4eec\u7684\u548c  \n    return num(p->Lson) + num(p->Rson);  \n}<\/code><\/pre>\n\n\n\n
7-1 \u6808\u7684\u57fa\u672c\u64cd\u4f5c<\/strong><\/p>\n\n\n\n
#include <stack>\n#include <iostream>\nusing namespace std;\nint main(){\n    int n,tem;\n    stack <int> sxr;\n    cin>>n;\n    for(int i=0;i<n;i++){\n        cin>>tem;\n        if(tem!=0){\n            if(sxr.size()==10) cout<<\"FULL \";\n            else sxr.push(tem);\n        }\n        else{\n            if(!sxr.empty()){\n                cout<<sxr.top()<<\" \";\n                sxr.pop();\n            }\n            else cout<<\"EMPTY \";\n        }\n    }\n    cout<<endl;\n    while(!sxr.empty()){\n        cout<<sxr.top()<<\" \";\n        sxr.pop();\n    }\n}<\/code><\/pre>\n\n\n\n
7-2 Windows\u6d88\u606f\u961f\u5217<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>  \nusing namespace std;  \nstruct Message {  \n    string name;  \n    int priority;  \n    Message(const string& n, int p) : name(n), priority(p) {}  \n    \/\/ \u6bd4\u8f83\u51fd\u6570\uff0c\u7528\u4e8e\u4f18\u5148\u961f\u5217\u7684\u81ea\u5b9a\u4e49\u6392\u5e8f  \n    bool operator<(const Message& other) const {  \n        \/\/ \u6ce8\u610f\u8fd9\u91cc\u7684\u6bd4\u8f83\u662f\u53cd\u7684\uff0c\u56e0\u4e3a\u4f18\u5148\u7ea7\u503c\u8d8a\u5c0f\u4f18\u5148\u7ea7\u8d8a\u9ad8  \n        return priority > other.priority;  \n    }  \n};  \n  \nint main() {  \n    int n;  \n    cin >> n;  \n  \n    priority_queue<Message> msgQueue;  \n  \n    while (n--) {  \n        string command;  \n        cin >> command;  \n  \n        if (command == \"PUT\") {  \n            string msgName;  \n            int priority;  \n            cin >> msgName >> priority;  \n            msgQueue.push(Message(msgName, priority));  \n        } else if (command == \"GET\") {  \n            if (msgQueue.empty()) {  \n                cout << \"EMPTY QUEUE!\" << endl;  \n            } else {  \n                Message msg = msgQueue.top();  \n                msgQueue.pop();  \n                cout << msg.name << endl;  \n            }  \n        }  \n    }  \n  \n    return 0;  \n}<\/code><\/pre>\n\n\n\n
7-3 \u6c42\u89e3\u53f3\u6700\u503c\u95ee\u9898<\/strong><\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\nint main(void)\n{\n    int n,i,j,a[20],b[20],count=0,flag=0;\n    cin >> n;\n    for(i=0;i<n;i++) cin >>a[i];\n    for(i=0;i<n;i++)\n    {\n        flag=0;\n        for(j=i+1;j<n;j++)\n        {\n            if(a[i]<a[j]) flag++;\n        }\n        if(flag==0)\n        {\n            b[count]=a[i];\n            count++;\n        }\n    }\n    for(i=0;i<count;i++) cout << b[i] << \" \";\n}<\/code><\/pre>\n\n\n\n
7-4 \u961f\u7684\u57fa\u672c\u64cd\u4f5c<\/strong><\/p>\n\n\n\n
\/\/\u6ce8\u610f\uff1a\u8fd9\u91cc\u662f\u91c7\u7528\u5faa\u73af\u961f\u5217\u5b8c\u6210\uff0c\u7981\u7528\u4e00\u4e2a\u7a7a\u95f4\u7684\u65b9\u6cd5\n\/\/\u7981\u7528\u4e00\u4e2a\u7a7a\u95f4\n\n#include <queue>\n#include <iostream>\nusing namespace std;\nint main(){\n    int n,tem;\n    queue <int> sxr;\n    cin>>n;\n    for(int i=0;i<n;i++){\n        cin>>tem;\n        if(tem!=0){\n            if(sxr.size()==9) cout<<\"FULL \";\n            else sxr.push(tem);\n        }\n        else{\n            if(!sxr.empty()){\n                cout<<sxr.front()<<\" \";\n                sxr.pop();\n            }\n            else cout<<\"EMPTY \";\n        }\n    }\n    cout<<endl;\n    while(!sxr.empty()){\n        cout<<sxr.front()<<\" \";\n        sxr.pop();\n    }\n}<\/code><\/pre>\n\n\n\n
7-5 \u77e9\u9635A\u4e58\u4ee5B<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\nusing namespace std;\n\nint main(){\n    int ra,ca,rb,cb,sum=0;\n    int a[100][100];\n    int b[100][100];\n    \n    cin>>ra>>ca;\n    for(int i=0;i<ra;i++){\n        for(int j=0;j<ca;j++){\n            cin>>a[i][j];\n        }\n    }\n    \n    cin>>rb>>cb;\n    for(int i=0;i<rb;i++){\n        for(int j=0;j<cb;j++){\n            cin>>b[i][j];\n        }\n    }\n    if(ca!=rb) cout<<\"Error: \"<<ca<<\" != \"<<rb;\n    else{\n        cout<<ra<<\" \"<<cb<<endl;\n        for(int i=0;i<ra;i++){\n            for(int j=0;j<cb;j++){\n                sum=0;\n                for(int k=0;k<ca;k++){\n                    sum+=a[i][k]*b[k][j];\n                }\n                cout<<sum;\n                if(j!=cb-1) cout<<\" \";\n            }\n            cout<<endl;\n        }\n    }\n}<\/code><\/pre>\n\n\n\n
7-6 \u6784\u9020\u6563\u5217\u8868<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\nusing namespace std;\n\nint main(){\n    int n,a[18]={0},data,h;\n    cin>>n;\n    for(int i=0;i<n;i++){\n        cin>>data;\n        h=data%17;\n        if(a[h]==0)\n        {\n            a[h]=data;\n            cout<<data<<\" pos: \"<<h<<endl;\n        }\n        else{\n            while(a[h]!=0){\n                h=(h+5)%18;\n            }\n            a[h]=data;\n            cout<<data<<\" pos: \"<<h<<endl;\n        }\n    }\n}<\/code><\/pre>\n\n\n\n
7-7 \u6563\u5217\u8868\u67e5\u627e<\/strong><\/p>\n\n\n\n
\/\/\u672c\u9898\u7684\u5751\u70b9\uff1a\u5f53\u60f3\u8981\u67e5\u627e0\u7684\u65f6\u5019\uff0c\u82e5\u8bbe\u7f6e\u7684a[18]\u521d\u59cb\u503c\u4e3a0\uff0c\u5219\u6b64\u65f6\u4f1a\u62a5\u627e\u5230\u4e86\uff0c\u8fd9\u4e0d\u7b26\u5408\u6211\u4eec\u60f3\u8981\u7684\u67e5\u627e\u5b58\u4e0d\u5b58\u57280\n\n\n#include <bits\/stdc++.h>  \nusing namespace std;  \n  \nint main() {  \n    \/\/ \u521d\u59cb\u5316\u6563\u5217\u8868\u6570\u7ec4a\uff0c\u5927\u5c0f\u4e3a18\uff0c\u6240\u6709\u5143\u7d20\u521d\u59cb\u5316\u4e3a0  \n    int a[18];\n    memset(a,-1,sizeof(a));\n    int n, data, cou = 0;  \n  \n    \/\/ \u7b2c\u4e00\u4e2a\u5faa\u73af\uff1a\u63a5\u6536\u6570\u636e\u5e76\u5b58\u50a8\u5230\u6563\u5217\u8868  \n    cin >> n;  \n    for (int i = 0; i < n; i++) {  \n        cin >> data;  \n        int h = data % 17; \/\/ \u8ba1\u7b97\u54c8\u5e0c\u503c  \n        int k = 0;  \n        int hp = h; \/\/ \u521d\u59cb\u4f4d\u7f6e\u4e3a\u54c8\u5e0c\u503c\u5bf9\u5e94\u7684\u4f4d\u7f6e  \n  \n        \/\/ \u67e5\u627e\u7b2c\u4e00\u4e2a\u7a7a\u4f4d\u7f6e\u5b58\u50a8\u6570\u636e  \n        while (a[hp] != -1) {  \n            k++;  \n            hp = (h + k * k) % 18;  \n        }  \n        a[hp] = data; \/\/ \u5c06\u6570\u636e\u5b58\u50a8\u5230\u627e\u5230\u7684\u4f4d\u7f6e  \n        cout << hp << \" \"; \/\/ \u8f93\u51fa\u5b58\u50a8\u4f4d\u7f6e  \n    }  \n    cout << endl; \/\/ \u8f93\u51fa\u6362\u884c  \n  \n    \/\/ \u7b2c\u4e8c\u4e2a\u5faa\u73af\uff1a\u63a5\u6536\u6570\u636e\u5e76\u67e5\u627e\u5728\u6563\u5217\u8868\u4e2d\u7684\u4f4d\u7f6e  \n    cin >> n;  \n    for (int i = 0; i < n; i++) {  \n        cin >> data;  \n        cou = 1; \/\/ \u5c1d\u8bd5\u6b21\u6570\u521d\u59cb\u5316\u4e3a1  \n        int h = data % 17; \/\/ \u8ba1\u7b97\u54c8\u5e0c\u503c  \n        int k = 0;  \n        int hp = h; \/\/ \u521d\u59cb\u4f4d\u7f6e\u4e3a\u54c8\u5e0c\u503c\u5bf9\u5e94\u7684\u4f4d\u7f6e  \n  \n        \/\/ \u67e5\u627e\u6570\u636e\u5728\u6563\u5217\u8868\u4e2d\u7684\u4f4d\u7f6e  \n        while (a[hp] != data && a[hp] != -1) {  \n            cou++; \/\/ \u5c1d\u8bd5\u6b21\u6570\u52a01  \n            k++;  \n            hp = (h + k * k) % 18; \/\/ \u4f7f\u7528\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u4e0b\u4e00\u4e2a\u53ef\u80fd\u7684\u4f4d\u7f6e  \n        }  \n  \n        \/\/ \u8f93\u51fa\u7ed3\u679c  \n        if (a[hp] == data)  \n            cout << data << \" pos:\" << hp << \",try \" << cou << endl;  \n        else  \n            cout << data << \" not found,try \" << cou << endl;  \n    }  \n  \n    return 0;  \n}<\/code><\/pre>\n\n\n\n
7-8 \u540e\u5e8f\u548c\u4e2d\u5e8f\u6784\u9020\u4e8c\u53c9\u6811<\/strong><\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nstruct TreeNode {\n    int val;\n    TreeNode* left;\n    TreeNode* right;\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n\n\/\/ \u4f7f\u7528\u540e\u5e8f\u548c\u4e2d\u5e8f\u5e8f\u5217\u6784\u5efa\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u51fd\u6570\nTreeNode* buildTree(int postorder[], int inorder[], int postStart, int postEnd, int inStart, int inEnd) {\n    if (postStart > postEnd) return nullptr;\n    \n    \/\/ \u540e\u5e8f\u5e8f\u5217\u7684\u6700\u540e\u4e00\u4e2a\u5143\u7d20\u662f\u6839\u8282\u70b9\n    TreeNode* root = new TreeNode(postorder[postEnd]);\n    int inRootIndex = -1;\n    \/\/ \u5728\u4e2d\u5e8f\u5e8f\u5217\u4e2d\u627e\u5230\u6839\u8282\u70b9\u7684\u7d22\u5f15\n    for (int i = inStart; i <= inEnd; ++i) {\n        if (inorder[i] == root->val) {\n            inRootIndex = i;\n            break;\n        }\n    }\n    \/\/ \u9012\u5f52\u6784\u5efa\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\n    root->left = buildTree(postorder, inorder, postStart, postStart + inRootIndex - inStart - 1, inStart, inRootIndex - 1);\n    root->right = buildTree(postorder, inorder, postStart + inRootIndex - inStart, postEnd - 1, inRootIndex + 1, inEnd);\n    \n    return root;\n}\n\n\/\/ \u5148\u5e8f\u904d\u5386\u4e8c\u53c9\u6811\u5e76\u6253\u5370\nvoid preorderTraversal(TreeNode* root) {\n    if (!root) return;\n    cout << root->val << \" \";\n    preorderTraversal(root->left);\n    preorderTraversal(root->right);\n}\n\nint main() {\n    int n;\n    cin >> n;\n    int postorder[10], inorder[10];\n    \n    \/\/ \u8bfb\u53d6\u540e\u5e8f\u5e8f\u5217\n    for (int i = 0; i < n; ++i) cin >> postorder[i];\n    \/\/ \u8bfb\u53d6\u4e2d\u5e8f\u5e8f\u5217\n    for (int i = 0; i < n; ++i) cin >> inorder[i];\n    \n    \/\/ \u6784\u5efa\u4e8c\u53c9\u6811\u5e76\u904d\u5386\n    TreeNode* root = buildTree(postorder, inorder, 0, n - 1, 0, n - 1);\n    preorderTraversal(root);\n    \n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-9 \u5148\u5e8f\u548c\u540e\u5e8f\u6784\u9020\u6b63\u5219\u4e8c\u53c9\u6811<\/strong><\/p>\n\n\n\n
#include <iostream>\n#include <vector>\n#include <unordered_map>\nusing namespace std;\n\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n\n\/\/ \u901a\u8fc7\u5148\u5e8f\u5e8f\u5217\u548c\u540e\u5e8f\u5e8f\u5217\u6784\u9020\u6b63\u5219\u4e8c\u53c9\u6811\nTreeNode* buildTree(vector<int>& preorder, vector<int>& postorder, int preStart, int preEnd, int postStart, int postEnd) {\n    if (preStart > preEnd || postStart > postEnd) {\n        return nullptr;\n    }\n\n    TreeNode* root = new TreeNode(preorder[preStart]);\n\n    if (preStart == preEnd) {\n        return root;\n    }\n\n    int leftRootValue = preorder[preStart + 1];\n    int leftRootIndexPost = postStart;\n    while (postorder[leftRootIndexPost] != leftRootValue) {\n        leftRootIndexPost++;\n    }\n\n    int leftSubtreeSize = leftRootIndexPost - postStart + 1;\n\n    root->left = buildTree(preorder, postorder, preStart + 1, preStart + leftSubtreeSize, postStart, leftRootIndexPost);\n    root->right = buildTree(preorder, postorder, preStart + leftSubtreeSize + 1, preEnd, leftRootIndexPost + 1, postEnd - 1);\n\n    return root;\n}\n\n\/\/ \u4e2d\u5e8f\u904d\u5386\uff0c\u83b7\u53d6\u4e2d\u5e8f\u5e8f\u5217\nvoid inorderTraversal(TreeNode* root, vector<int>& inorder) {\n    if (root == nullptr) {\n        return;\n    }\n    inorderTraversal(root->left, inorder);\n    inorder.push_back(root->val);\n    inorderTraversal(root->right, inorder);\n}\n\nint main() {\n    int n;\n    cin >> n;\n\n    vector<int> preorder(n);\n    vector<int> postorder(n);\n\n    for (int i = 0; i < n; ++i) {\n        cin >> preorder[i];\n    }\n\n    for (int i = 0; i < n; ++i) {\n        cin >> postorder[i];\n    }\n\n    \/\/ \u6784\u9020\u4e8c\u53c9\u6811\n    TreeNode* root = buildTree(preorder, postorder, 0, n - 1, 0, n - 1);\n\n    \/\/ \u4e2d\u5e8f\u904d\u5386\u8f93\u51fa\u4e2d\u5e8f\u5e8f\u5217\n    vector<int> inorder;\n    inorderTraversal(root, inorder);\n\n    \/\/ \u8f93\u51fa\u4e2d\u5e8f\u5e8f\u5217\n    for (int i = 0; i < n; ++i) {\n        cout << inorder[i];\n        if (i < n - 1) {\n            cout << \" \";\n        } else {\n            cout << \" \" << endl;\n        }\n    }\n\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-10 \u6784\u9020\u4e8c\u53c9\u68c0\u7d22\u6811<\/strong><\/p>\n\n\n\n
#include <iostream>  \n  \nusing namespace std;  \n  \nstruct node {  \n    int val;  \n    node *lson, *rson;  \n};  \n  \nvoid app(node*& z, node* x) {  \n    if (z == nullptr) {  \n        z = x;  \n        return;  \n    }  \n    if (x->val <= z->val) {  \n        app(z->lson, x);  \n    } else {  \n        app(z->rson, x);  \n    }  \n}  \n  \nvoid out(node* l) {  \n    if (l == nullptr) {  \n        return;  \n    }  \n    cout << l->val << \" \";  \n    out(l->lson);  \n    out(l->rson);  \n}  \n  \nint main() {  \n    int x;  \n    node* root = nullptr;  \n    while (cin >> x && x != 0) {  \n        node* tem = new node{x, nullptr, nullptr};  \n        app(root, tem);  \n    }  \n    out(root);  \n    return 0;  \n}<\/code><\/pre>\n\n\n\n
7-11 \u662f\u5426\u5b8c\u5168\u4e8c\u53c9\u641c\u7d22\u6811<\/strong><\/p>\n\n\n\n
#include<stdio.h>\n#include<stdlib.h>\ntypedef struct TNode* BinTree;\nstruct TNode{\n    int Data;\n    BinTree Left;\n    BinTree Right;\n};\nBinTree Insert( BinTree BST, int x )\n{\n    if(!BST){\n        BST=(BinTree)malloc(sizeof(struct TNode));\n        BST->Data=x;\n        BST->Left=BST->Right=NULL;\n    }\n    else{\n        if(x>BST->Data) BST->Left=Insert( BST->Left, x );\n        else if(x<BST->Data) BST->Right=Insert( BST->Right, x );\n    }\n    return BST;\n}\nvoid Out(BinTree BST)\n{\n    int i,front=0,tail=0,p=0;\n    BinTree a[30],x;\n    a[++tail]=BST;\n    while(tail!=front){\n        x=a[++front];\n        if(p==0) {\n            printf(\"%d\",x->Data);\n            p=1;\n        }\n        else printf(\" %d\",x->Data);\n        if(x->Left) a[++tail]=x->Left;\n        if(x->Right) a[++tail]=x->Right;\n    }\n}\nvoid Pan(BinTree BST)\n{\n    int i,front=0,tail=0,q=0;\n    BinTree a[30],x;\n    a[++tail]=BST;\n    while(tail!=front){\n        x=a[++front];\n        if(!x->Left&&x->Right){\n        \tprintf(\"\\nNO\");\n        \treturn;\n\t\t}\n        if(x->Left&&x->Right){\n\t\t\ta[++tail]=x->Left;\n\t\t\ta[++tail]=x->Right;\n\t\t}\n        if(!x->Right&&x->Left){\n\t\t\ta[++tail]=x->Left;\n\t\t\tq=1;\n\t\t}\n\t\tif(!x->Right&&!x->Left) q=1;\n\t\twhile(q==1&&tail!=front){\n\t\t\tx=a[++front];\n\t\t\tif(x->Left||x->Right){\n\t\t\t\tprintf(\"\\nNO\");\n        \t\treturn;\n\t\t\t}\n\t\t}\n    }\n    printf(\"\\nYES\");\n}\nint main()\n{\n    int n,i,x;\n    BinTree BST=NULL;\n    scanf(\"%d\",&n);\n    for(i=0;i<n;i++){\n        scanf(\"%d\",&x);\n        BST=Insert(BST, x);\n    }\n    Out(BST);\n    Pan(BST);\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-12 \u6784\u9020\u54c8\u592b\u66fc\u6811-\u65e0\u5e8f\u8f93\u5165<\/strong><\/p>\n\n\n\n
#include <iostream>\n#include <climits>\nusing namespace std;\n\nstruct node{\n    int data, parent, lson, rson;\n}sxr[22];\n\nint n;\n\nvoid inorder_traversal(int index) {\n    if (index==-1){\n        return;\n    }\n    inorder_traversal(sxr[index].lson);\n    printf(\"%d \", sxr[index].data);\n    inorder_traversal(sxr[index].rson);\n}\n\nvoid select(node hf[], int k, int &t1, int &t2){\n    int min1 = INT_MAX, min2 = INT_MAX;\n    t1 = t2 = -1;\n    for(int i = 0; i < n + k; i++){ \n        if(hf[i].parent == -1 && hf[i].data < min1){\n            min2 = min1;\n            t2 = t1;\n            min1 = hf[i].data;\n            t1 = i;\n        }\n        else if(hf[i].parent == -1 && hf[i].data < min2 && t1 != i){\n            min2 = hf[i].data;\n            t2 = i;\n        }\n    }\n}\n\n\nint main(){\n    int i, j,k;\n    cin >> n;\n    for(i = 0; i < n; i++){\n        cin >> sxr[i].data;\n        sxr[i].parent = sxr[i].lson = sxr[i].rson = -1;\n    }\n    for(k = 0; k < n-1; k++){\n        select(sxr, k, i, j);\n        if(i == -1 || j == -1) break;\n        sxr[n + k].data = sxr[i].data + sxr[j].data;\n        sxr[n + k].parent = -1;\n        sxr[n + k].lson = i;\n        sxr[n + k].rson = j;\n        sxr[i].parent = sxr[j].parent = n + k;\n    }\n\n    for(i=0;i<2*n-1;i++){\n        if(sxr[i].parent==-1){\n            inorder_traversal(i);\n            break;\n        }\n    }\n\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
7-13 \u56fe\u7684\u5b58\u50a8-\u90bb\u63a5\u8868<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\nusing namespace std;\nint main(){\n    int n,m,s,x,y;\n    cin>>n>>m>>s;\n    vector<int> v[n];\n    for(int i=0;i<m;i++){\n        cin>>x>>y;\n        v[x-1].push_back(y-1);\n        if(s==0){\n            v[y-1].push_back(x-1);\n        }\n    }\n    for(int i=0;i<n;i++){\n        cout<<i<<\":\";\n        for(int j=v[i].size()-1;j>=0;j--){\n            cout<<v[i][j]<<\" \";\n        }\n        cout<<endl;\n    }\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-14 \u56fe\u7684\u5b58\u50a8-\u90bb\u63a5\u77e9\u9635<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\nusing namespace std;\nint main(){\n    int n,m,s,sxr[52][52]={0},x,y;\n    cin>>n>>m>>s;\n    for(int i=0;i<m;i++){\n        cin>>x>>y;\n        sxr[x][y]=1;\n    }\n    if(s==0){\n        for(int i=1;i<=n;i++){\n            for(int j=1;j<=n;j++){\n                if(sxr[i][j]!=0){\n                    sxr[j][i]=sxr[i][j];\n                }\n                if(sxr[j][i]!=0){\n                    sxr[i][j]=sxr[j][i];\n                }\n            }\n        }\n    }\n\n\n    for(int i=1;i<=n;i++){\n        for(int j=1;j<=n;j++){\n            cout<<sxr[i][j]<<\" \";\n        }\n        cout<<endl;\n    }\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-15 \u56fe\u7684\u5148\u5e7f\u641c\u7d22<\/strong><\/p>\n\n\n\n
#include<stdio.h>\n#include<malloc.h>\ntypedef struct edgenode{\n    int adjacent;\n    struct edgenode *next;\n}edgenode,*eptr;\ntypedef struct{\n    int mark;\n    eptr firstedge;\n}hnode;\n\nvoid creatlist(hnode l[],int n,int m){\n    eptr p;\n    int v1,v2;\n    for (int i=0;i<n;i++){\n        l[i].mark=0;\n        l[i].firstedge=NULL;\n    }\n    for (int i=0;i<m;i++){\n        scanf(\"%d %d\",&v1,&v2);\n        p=(eptr)malloc(sizeof(edgenode));\n        p->adjacent=v2-1;\n        p->next=l[v1-1].firstedge;\n        l[v1-1].firstedge=p;\n        p=(eptr)malloc(sizeof(edgenode));\n        p->adjacent=v1-1;\n        p->next=l[v2-1].firstedge;\n        l[v2-1].firstedge=p;\n    }\n}\nvoid bfs(hnode l[],int n,int v){\n    eptr p;\n    int u,w,first,last,q[n];\n    first=last=0;\n    for(u=0;u<n;u++)l[u].mark=0;\n    for (u=0;u<n;u++)\n        if (l[v].mark==0){\n            q[last++]=v;\n            l[v].mark=1;\n            while(first!=last){\n                v=q[first++];\n                printf(\"%d \",v+1);\n                p=l[v].firstedge;\n                while(p!=NULL){\n                    w=p->adjacent;\n                    if (l[w].mark==0){\n                        q[last++]=w;\n                        l[w].mark=1;\n                    }\n                    p=p->next;\n                }\n            }\n        }\n}\nint main(){\n    int n,m,s;\n    int num=0;\n    scanf(\"%d %d %d\",&n,&m,&s);\n    hnode l[10];\n    creatlist(l,n,m);\n    bfs(l,n,s-1);\n    for (int i=0;i<n;i++){\n        if (l[i].mark==1){\n            num++;\n        }\n    }\n    if (num!=n){\n        printf(\"\\n0\");\n    }\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
7-16 \u6700\u5c0f\u751f\u6210\u6811-kruskal\u7b97\u6cd5<\/strong><\/p>\n\n\n\n
#include <iostream>\n#include <vector>\n#include <algorithm>\n#include <set>\n\nusing namespace std;\n\nstruct Edge {\n    int u, v, cost;\n    bool operator<(const Edge& other) const {\n        return cost < other.cost;\n    }\n};\n\nint find(int x, vector<int>& parent) {\n    if (parent[x] != x) {\n        parent[x] = find(parent[x], parent);\n    }\n    return parent[x];\n}\n\nbool unionSet(int x, int y, vector<int>& parent, vector<int>& rank) {\n    int rootX = find(x, parent);\n    int rootY = find(y, parent);\n    if (rootX != rootY) {\n        if (rank[rootX] < rank[rootY]) {\n            parent[rootX] = rootY;\n        } else if (rank[rootX] > rank[rootY]) {\n            parent[rootY] = rootX;\n        } else {\n            parent[rootY] = rootX;\n            rank[rootX]++;\n        }\n        return true;\n    }\n    return false;\n}\n\nint main() {\n    int N, M;\n    cin >> N >> M;\n    \n    vector<Edge> edges;\n    for (int i = 0; i < M; ++i) {\n        int u, v, cost;\n        cin >> u >> v >> cost;\n        edges.push_back({u, v, cost});\n    }\n    \n    sort(edges.begin(), edges.end());\n    \n    vector<int> parent(N + 1);\n    vector<int> rank(N + 1, 0);\n    for (int i = 1; i <= N; ++i) {\n        parent[i] = i;\n    }\n    \n    vector<Edge> mst;\n    for (const Edge& edge : edges) {\n        if (unionSet(edge.u, edge.v, parent, rank)) {\n            mst.push_back(edge);\n        }\n    }\n    \n    for (const Edge& edge : mst) {\n        cout << min(edge.u, edge.v) << \",\" << max(edge.u, edge.v) << \",\" << edge.cost << endl;\n    }\n    \n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-17 \u6700\u5c0f\u751f\u6210\u6811-Prim\u7b97\u6cd5\uff08\u4ece\u4efb\u610f\u9876\u70b9\u5f00\u59cb\uff09<\/strong><\/p>\n\n\n\n
#include<bits\/stdc++.h>\nusing namespace std;\nint inf=0x3f3f3f3f;\nint graph[10000][10000]={0};\nint lowcost[10000]={0};\/\/\u70b9\u96c6\nint tree[10000]={0};\nint m,n,ls;\nvoid prim(int s)\n{\n    for(int i=1;i<=n;i++)\n    {\n        if(i==s)\n            lowcost[i]=0;\n        else\n        lowcost[i]=graph[s][i];\n        tree[i]=s;\/\/\u521d\u59cb\u5316\uff0c\u6240\u6709\u7684\u8fb9\u90fd\u5f85\u9009\n    }\n    int minn,pos;\n    for(int i=1;i<n;i++)\/\/\u5faa\u73af\u4e86n-1\u6b21\uff0c\u56e0\u4e3an\u4e2a\u70b9\uff0cn-1\u4e2a\u8fb9\n    {\n        minn=inf;\n        for(int j=1;j<=n;j++)\n        {\n            if(lowcost[j]!=0&&lowcost[j]<minn)\n            {\n                minn=lowcost[j];\n                pos=j;\n            }\/\/\u8fd9\u4e2a\u627e\u7684\u5c31\u662f\u70b9\u96c6\u5468\u56f4\u7684\u6700\u5c0f\u8fb9\n        }\n        cout<<(tree[pos]<pos?tree[pos]:pos)<<\",\"<<(tree[pos]>pos?tree[pos]:pos)<<\",\"<<graph[tree[pos]][pos]<<endl;\/\/\u6bcf\u627e\u5230\u4e00\u4e2a\u8fb9\u5c31\u8f93\u51fa\u4e00\u4e2a\u8fb9\n        if(minn==inf)\n            break;\n        lowcost[pos]=0;\/\/\u52a0\u5165\uff01\uff01\n        for(int j=1;j<=n;j++)\n        {\n            if(lowcost[j]!=0&&graph[pos][j]<lowcost[j])\/\/\u56e0\u4e3a\u6ca1\u5728\u70b9\u96c6\u91cc\uff0cs\u5230j\u6bd4\u8f83\u5927\uff0cpos\u5230j\u5c0f\uff0c\u5c31\u66f4\u65b0\u4e00\u4e0b\n            {\n                lowcost[j]=graph[pos][j];\/\/\u5176\u5b9e\u5c31\u662f\u70b9\u96c6\u5230j\u6700\u77ed\u7684\u8ddd\u79bb\n                tree[j]=pos;\/\/\u52a0\u5165\u5230tree\u7684\u5f85\u9009\uff0c\u4e0b\u6b21\u5faa\u73af\u4f1a\u9009\u51fa\u6765\u5408\u9002\u7684\uff0c\u5230\u65f6\u5019\u8fd9\u91cc\u7684j\u4f1a\u662f\u5408\u9002\u7684pos\uff0c\u8fd9\u91cc\u7684pos\u5bf9\u5e94\u4e0a\u4e00\u6b21\u5408\u9002\u7684\u503c\u3002\n            }\n        }\n    }\n}\nint main()\n{\n    cin>>n>>m>>ls;\n    for(int i=1;i<=n;i++)\n        for(int j=1;j<=n;j++)\n            graph[i][j]=inf;\n    for(int i=0;i<m;i++)\n    {\n        int a,b;\n        cin>>a>>b;\n        cin>>graph[a][b];\n        graph[b][a]=graph[a][b];\n    }\n    prim(ls);\n}<\/code><\/pre>\n\n\n\n
7-18 \u6700\u77ed\u8def\u5f84-Dijkstra<\/strong><\/p>\n\n\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <stdbool.h>\n#include <limits.h>\n\n#define MAX_SIZE 10\n#define INF 1000\n\nvoid dijkstra(int graph[MAX_SIZE][MAX_SIZE], int start, int N) {\n    int distance[MAX_SIZE];  \/\/ \u5b58\u50a8\u8d77\u59cb\u70b9\u5230\u5404\u4e2a\u70b9\u7684\u6700\u77ed\u8ddd\u79bb\n    bool visited[MAX_SIZE];  \/\/ \u8bb0\u5f55\u8282\u70b9\u662f\u5426\u5df2\u8bbf\u95ee\n    int i,j;\n\n    \/\/ \u521d\u59cb\u5316\u8ddd\u79bb\u548c\u8bbf\u95ee\u72b6\u6001\n    for (i = 0; i < N; i++) {\n        distance[i] = INF;\n        visited[i] = false;\n    }\n\n    \/\/ \u8bbe\u7f6e\u8d77\u59cb\u70b9\u7684\u6700\u77ed\u8ddd\u79bb\u4e3a0\n    distance[start] = 0;\n\n    \/\/ \u4f9d\u6b21\u627e\u5230\u8ddd\u79bb\u6700\u77ed\u7684\u8282\u70b9\u5e76\u66f4\u65b0\u5176\u4ed6\u8282\u70b9\u7684\u6700\u77ed\u8ddd\u79bb\n    for (i = 0; i < N; i++) {\n        int min_dis = INF;\n        int min_node = -1;\n\n        \/\/ \u627e\u5230\u5f53\u524d\u6700\u5c0f\u8ddd\u79bb\u7684\u8282\u70b9\n        for (j = 0; j < N; j++) {\n            if (!visited[j] && distance[j] < min_dis) {\n                min_dis = distance[j];\n                min_node = j;\n            }\n        }\n\n        \/\/ \u6807\u8bb0\u8be5\u8282\u70b9\u5df2\u8bbf\u95ee\n        visited[min_node] = true;\n\n        \/\/ \u66f4\u65b0\u5176\u4ed6\u8282\u70b9\u7684\u6700\u77ed\u8ddd\u79bb\n        for (j = 0; j < N; j++) {\n            if (!visited[j] && graph[min_node][j] != INF && distance[j] > distance[min_node] + graph[min_node][j]) {\n                distance[j] = distance[min_node] + graph[min_node][j];\n            }\n        }\n    }\n\n    \/\/ \u8f93\u51fa\u6700\u77ed\u8ddd\u79bb\n    for (i = 0; i < N; i++) {\n        if (distance[i] >=1000) {\n            printf(\"%d->%d:no path\\n\", start + 1, i + 1);\n        } else {\n            printf(\"%d->%d:%d\\n\", start + 1, i + 1, distance[i]);\n        }\n    }\n}\n\nint main() {\n    int N, M, directed;\n    int i,j,u, v, time, start;\n\n    \/\/ \u8bfb\u53d6\u8f93\u5165\n    scanf(\"%d %d %d\", &N, &M, &directed);\n\n    \/\/ \u6784\u5efa\u56fe\u7684\u90bb\u63a5\u77e9\u9635\n    int graph[MAX_SIZE][MAX_SIZE];\n    for (i = 0; i < N; i++) {\n        for (j = 0; j < N; j++) {\n            graph[i][j] = INF;\n        }\n    }\n\n    for (i = 0; i < M; i++) {\n        scanf(\"%d %d %d\", &u, &v, &time);\n        graph[u-1][v-1] = time;\n        if (!directed) {\n            graph[v-1][u-1] = time;\n        }\n    }\n\n    \/\/ \u9009\u62e9\u8d77\u59cb\u70b9\n    scanf(\"%d\", &start);\n    start--;\n\n    \/\/ \u8c03\u7528Dijkstra\u7b97\u6cd5\u8ba1\u7b97\u6700\u77ed\u8ddd\u79bb\n    dijkstra(graph, start, N);\n\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
7-19 \u6c42\u6700\u77ed\u8def\u5f84-flyod\u7b97\u6cd5<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\nusing namespace std;\n\nint graph[15][15];\nint n,m,s,x,y;\n\nvoid flyod(){\n    for(int k=0;k<n;k++){\n        for(int i=0;i<n;i++){\n            for(int j=0;j<n;j++){\n                if(graph[i][k]+graph[k][j]<graph[i][j]){\n                    graph[i][j]=graph[i][k]+graph[k][j];\n                }\n            }\n        }\n    }\n    return;\n}\n\n\nint main(){\n    int maxx,maxxnum;\n    memset(graph,999,sizeof(graph));\n    cin>>n>>m>>s;\n    for(int i=0;i<n;i++){\n        graph[i][i]=0;\n    }\n    for(int i=0;i<m;i++){\n        cin>>x>>y;\n        cin>>graph[x-1][y-1];\n        if(s==0){\n            graph[y-1][x-1]=graph[x-1][y-1];\n        }\n    }\n    flyod();\n    \/*\n    for(int i=0;i<n;i++){\n        for(int j=0;j<n;j++){\n            cout<<graph[i][j]<<\" \";\n        }\n        cout<<endl;\n    }\n    *\/\n    maxx=INT_MAX;\n    maxxnum=0;\n    for(int i=0;i<n;i++){\n        int smax=0;\n        for(int j=0;j<n;j++){\n            if(graph[i][j]>smax){\n                smax=graph[i][j];\n            }\n        }\n        if(smax<maxx){\n            maxx=smax;\n            maxxnum=i;\n        }\n    }\n    cout<<maxxnum+1;\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-20 \u6709\u5411\u56fe\u7684\u62d3\u6251\u5e8f\u5217<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\n \nusing namespace std;\n \n#define MAX_LENGTH 1010\n \nvector<int> G[MAX_LENGTH];\nint n, m, inDegree[MAX_LENGTH];\nstack<int> s;\n \nbool TopologicalOrder() {\n    int num = 0;\n    for (int i = 1; i <= n; i++) {\n        if (inDegree[i] == 0) {\n            s.push(i);\n        }\n    }\n    while (s.size()) {\n        int u = s.top();\n        cout << u << \" \";\n        s.pop();\n        for (int i = 0; i < G[u].size(); i++) {\n            int v = G[u][i];\n            inDegree[v]--;\n            if (inDegree[v] == 0) {\n                s.push(v);\n            }\n        }\n        num++;\n    }\n    if (num == n) return true;\n    else return false;\n}\n \nint main() {\n    int x, y;\n    cin >> n >> m;\n    memset(inDegree, 0, sizeof(inDegree));\n    for (int i = 1; i <= m; i++) {\n        cin >> x >> y;\n        inDegree[y]++;\n        if(!G[x].size()) G[x].push_back(y);\n        else{\n            G[x].insert(G[x].begin(), y);\n        }\n    }\n\n    if (!TopologicalOrder()) {\n        cout << endl;\n        cout << \"0\" << endl;\n    }\n    return 0;\n}\n<\/code><\/pre>\n\n\n\n
7-21 \u5192\u6ce1\u6392\u5e8f<\/strong><\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\nint main(void)\n{\n    int i,j,n,a[100],tem;\n    cin >> n;\n    for(i=0;i<n;i++) cin >> a[i];\n    for(i=0;i<3;i++)\n    {\n        for(j=n-1;j>i;j--)\n        {\n            if(a[j]<a[j-1])\n            {\n                tem=a[j];\n                a[j]=a[j-1];\n                a[j-1]=tem;\n            }\n        }\n        for(j=0;j<n;j++) cout << a[j] << \" \";\n        cout << endl;\n    }\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-22 \u7b80\u5355\u9009\u62e9\u6392\u5e8f<\/strong><\/p>\n\n\n\n
#include <iostream>;\nusing namespace std;\nint main(void)\n{\n    int n,i,j,tem,a[100],max,maxj;\n    cin >> n;\n    for(i=0;i<n;i++) cin >> a[i];\n\n    \n    for(i=0;i<3;i++)\n    {\n        max=a[0],maxj=0;\n        for(j=0;j<n-i;j++)\n        {\n            if(a[j]>max)\n            {\n                max=a[j];\n                maxj=j;\n            }\n        }\n        tem=a[n-i-1];\n        a[n-i-1]=a[maxj];\n        a[maxj]=tem;\n        for(j=0;j<n;j++) cout << a[j] <<\" \";\n        cout << endl;\n    }\n}<\/code><\/pre>\n\n\n\n
7-23 \u76f4\u63a5\u63d2\u5165\u6392\u5e8f<\/strong><\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\nint main(void)\n{\n    int n,i,j,a[100],count,tem;\n    cin >> n;\n    for(i=0;i<n;i++) cin >> a[i];\n    for(i=0;i<3;i++)\n    {\n        for(j=0;j<i+1;j++)\n        {\n            if(a[i+1]<=a[j])\n            {\n                tem=a[i+1];\n                a[i+1]=a[j];\n                a[j]=tem;\n            }\n        \n        }\n        for(j=0;j<n;j++) cout << a[j] <<\" \";\n        cout << endl;\n    }\n}<\/code><\/pre>\n\n\n\n
7-24 \u9012\u5f52\u4e8c\u8def\u5f52\u5e76\u6392\u5e8f<\/strong><\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\nint n,a[120],sxr=0;\n\nvoid merage(int p,int q,int s,int t){\n    int i=p,j=s,k=p-1,b[n];\n    while((i<=q)&&(j<=t))\n        if(a[i]<=a[j])\n            b[++k]=a[i++];\n        else\n            b[++k]=a[j++];\n    while(i<=q)\n        b[++k]=a[i++];\n    while(j<=t)\n        b[++k]=a[j++];\n    for(i=p;i<=t;i++)\n        a[i]=b[i];\n}\nvoid merage_sort(int i,int j){\n    int k;\n    if(i<j){\n        k=(i+j)\/2;\n        merage_sort(i,k);\n        merage_sort(k+1,j);\n        merage(i,k,k+1,j);\n        if(sxr<3){\n            for(int l=0;l<n;l++){\n                cout<<a[l]<<\" \";\n            }\n            sxr++;\n            cout<<endl;\n        }\n    }\n}\n\nint main(){\n    cin>>n;\n    for(int i=0;i<n;i++){\n        cin>>a[i];\n    }\n    merage_sort(0,n-1);\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-25 PAT\u6392\u540d\u6c47\u603b<\/strong><\/p>\n\n\n\n
#include<iostream>\n#include<algorithm>\n#include<vector>\nusing namespace std;\nstruct node\n{\n\tstring num;\/\/\u4e0d\u80fd\u7528Longlong\uff0clonglong\u7b2c\u4e00\u4f4d\u4e3a0\u4f1a\u81ea\u52a8\u5220\u9664 \n\tint score;\n\tint sumrank;\n\tint rank;\n\tint work;\n}student[30005];\/\/\u5b58\u5b66\u751f\u4fe1\u606f \nbool cmp(node* a,node* b)\n{\n\tif(a->score!=b->score)\n\treturn a->score>b->score;\n\treturn a->num<b->num;\n}\/\/\u6bd4\u8f83\u51fd\u6570\uff0c\u5206\u6570\u4e0d\u7b49\u6309\u5b66\u53f7\u6392 \nint main()\n{\n\tint T,t,n,i,j,k,s=0;\n\tvector<node*> q;\/\/vector\u5b58\u6307\u5411\u7ed3\u6784\u4f53\u7684\u6307\u9488 \n\tvector<node*>::iterator it;\n\tcin>>T;\n\tfor(i=1;i<=T;i++)\n\t{\n\t\tq.clear();\/\/\u6e05\u7a7a\uff0c\u5426\u5219\u4f1a\u5728\u539f\u57fa\u7840\u4e0a\u5b58\u6570\u636e \n\t\tcin>>n;\n\t\twhile(n--)\n\t\t{\n\t\t\tcin>>student[s].num>>student[s].score;\n\t\t\tstudent[s].work=i;\n\t\t\tq.push_back(&student[s]);\/\/\u538b\u5165\u7ed3\u6784\u4f53\u7684\u6307\u9488 \n\t\t\ts++;\/\/\u5b66\u751f\u6570\u91cf\u52a01 \n\t\t}\n\t\tsort(q.begin(),q.end(),cmp);\n\t\t(*q.begin())->rank=1;\/\/\u6ce8\u610f\u8fd9\u5730\u65b9\u7684\u8fd0\u7528\uff0c(*q.begin())\u662f\u6307\u5411\u7ed3\u6784\u4f53\u7684\u6307\u9488\uff0c\u5fc5\u987b\u52a0\u62ec\u53f7\uff0c->\u7684\u4f18\u5148\u7ea7\u5927\u4e8e*\uff0c*a.b\u7b49\u7ea7\u4e8ea->b \n\t\tfor(it=q.begin()+1,j=2;it!=q.end();it++,j++)\n\t\t{\n\t\t\t(*it)->rank=j;\/\/(*it)\u662f\u7ed3\u6784\u4f53\u7684\u5730\u5740 \n\t\t\tif((*it)->score==(*(it-1))->score)(*it)->rank=(*(it-1))->rank;\n\t\t}\t\n\t}\n   q.clear();\n   for(i=0;i<s;i++)\n   q.push_back(&student[i]);\n\t\n\t\n\t\tsort(q.begin(),q.end(),cmp);\n\t(*q.begin())->sumrank=1;\n\tfor(it=q.begin()+1,j=2;it!=q.end();it++,j++)\n\t{\n\t\t(*it)->sumrank=j;\n\t\tif((*it)->score==(*(it-1))->score) (*it)->sumrank=(*(it-1))->sumrank;\n\t}\n\t\n\tcout<<s<<endl;\n\tfor(i=0;i<s;i++)\n\tcout<<q[i]->num<<\" \"<<q[i]->sumrank<<\" \"<<q[i]->work<<\" \"<<q[i]->rank<<endl;\n\t\n}\n<\/code><\/pre>\n\n\n\n
7-26 \u5965\u8fd0\u6392\u884c\u699c<\/strong><\/p>\n\n\n\n
#include<stdio.h>\n#include<malloc.h>\n#include<stdlib.h>\n#include<string.h>\nstruct jp{\n    double jin;\n    double jiang;\n    double people;\n    double aver_jin;\n    double aver_jiang;\n}a[300];\nint main()\n{\n    int N,M,i,j;\n    int b[500];\/\/\u5b58\u50a8\u6700\u540e\u4e00\u884cM\u4e2a\u524d\u6765\u54a8\u8be2\u7684\u56fd\u5bb6\u7684\u7f16\u53f7\n    int p0,p1,p2,p3;\n    scanf(\"%d%d\",&N,&M);\n    for(i=0;i<N;i++)\n    {\n        scanf(\"%lf%lf%lf\",&a[i].jin,&a[i].jiang,&a[i].people);\n        a[i].aver_jin=a[i].jin\/a[i].people;\n        a[i].aver_jiang=a[i].jiang\/a[i].people;\n    }\n    for(i=0;i<M;i++)\n        scanf(\"%d\",&b[i]);\n    for(i=0;i<M;i++)\n    {\n        p0=0;p1=0;p2=0;p3=0;\n        for(j=0;j<N;j++)\n        {\n            if(a[b[i]].jin>=a[j].jin)  p0++;\n            if(a[b[i]].jiang>=a[j].jiang)  p1++;\n            if(a[b[i]].aver_jin>=a[j].aver_jin) p2++;\n            if(a[b[i]].aver_jiang>=a[j].aver_jiang) p3++;\n        }\n        int max=p0,t=1;\n        \/\/\u8ba1\u7b97\u91cd\u8981\u5ea6\u6392\u540d\u4e3a\u91d1\u724c\uff0c\u5956\u724c\uff0c\u4eba\u5747\u91d1\u724c\uff0c\u4eba\u5747\u5956\u724c\n        if(max<p1){max=p1;t=2;}\n        if(max<p2){max=p2;t=3;}\n        if(max<p3){max=p3;t=4;}\n        if(i==0)\n            printf(\"%d:%d\",N-max+1,t);\n        else printf(\" %d:%d\",N-max+1,t);\n        \/\/N-max+1\u4e3a\u8be5\u56fd\u5bb6\u6240\u80fd\u62ff\u5230\u7684\u6700\u9ad8\u540d\u6b21\u7684\u6392\u5e8f\u65b9\u5f0f\n        \/\/t\u4e3a\u6b64\u65b9\u5f0f\u80fd\u591f\u83b7\u5f97\u7684\u6700\u9ad8\u7684\u6392\u540d\n    }\n}\n<\/code><\/pre>\n\n\n\n
7-27 \u5bfb\u627e\u5927\u5bcc\u7fc1<\/strong><\/p>\n\n\n\n
#include <bits\/stdc++.h>\nusing namespace std;\nbool cmp(int x,int y){\n    if(x>=y)\n        return 1;\n    return 0;\n}\n\nint main(){\n    int sxr[1000050],n,m;\n    cin>>n>>m;\n    for(int i=0;i<n;i++){\n        cin>>sxr[i];\n    }\n    sort(sxr,sxr+n,cmp);\n    if(n>=m){\n        cout<<sxr[0];\n        for(int i=1;i<m;i++){\n            cout<<\" \"<<sxr[i];\n        }\n    }\n    else{\n        cout<<sxr[0];\n        for(int i=1;i<n;i++){\n            cout<<\" \"<<sxr[i];\n        }\n    }\n    return 0;\n}<\/code><\/pre>\n\n\n\n
7-28 \u58eb\u5175\u6392\u961f<\/strong><\/p>\n\n\n\n
#include<cstdio>\n#include<algorithm>\/\/sort\u51fd\u6570 \n#include<cstdlib> \/\/abs\u51fd\u6570\n\nusing namespace std;\n\nint main()\n{\n\tint n;\/\/\u58eb\u5175\u6570\n\tscanf(\"%d\",&n);\n\t\n\tint x[10000],y[10000];\n\t\/\/x\u6570\u7ec4\u5b58\u50a8\u58eb\u5175\u7684\u6a2a\u5750\u6807\uff0cy\u6570\u7ec4\u5b58\u50a8\u58eb\u5175\u7684\u7eb5\u5750\u6807\n\tint sum=0,rex,rey;\n\t\/\/sum\u8bb0\u5f55\u6b65\u6570\u4e4b\u548c\uff0crex\u8bb0\u5f55x\u65b9\u5411\u7684\u4e2d\u4f4d\u6570\uff0crey\u8bb0\u5f55y\u65b9\u5411\u7684\u4e2d\u4f4d\u6570\n\t\n\tint i;\n\tfor(i=1;i<=n;i++)\n\t\tscanf(\"%d%d\",x+i,y+i);\t\n\t\/\/\u6570\u636e\u7684\u8f93\u5165\u5230x[1]~x[n],y[1]~y[n],\u6b64\u5904\u4f7f\u7528\u7684\u662f\u6570\u7ec4\u5730\u5740\u6cd5 \n\t\n\tsort(x+1,x+n+1);\n\tsort(y+1,y+n+1);\n\t\/\/\u5bf9\u6570\u636ex[1]~x[n],y[1]~y[n]\u5206\u522b\u8fdb\u884c\u7531\u5c0f\u5230\u5927\u7684\u6392\u5e8f\n\t\n\tfor(i=1;i<=n;i++)\n\t\tx[i]=x[i]-i;\n\t\/\/\u6784\u9020x1-1\uff0cx2-2\uff0c......\uff0cxn-n\u6570\u5217 \n\t\n\tsort(x+1,x+n+1);\n\t\/\/\u5bf9\u65b0\u6570\u5217\u8fdb\u884c\u6392\u5e8f\n\t\n\tif(n%2==0)\/\/n\u4e3a\u5076\u6570 \n\t{\n\t\trex = (x[n\/2]+x[n\/2+1])\/2;\n\t\trey = (y[n\/2]+y[n\/2+1])\/2;\n\t}\n\telse\/\/n\u4e3a\u5947\u6570 \n\t{\n\t\trex = x[n\/2+1];\n\t\trey = y[n\/2+1];\t\n\t} \n\t\n\t\/\/\u4e0b\u9762\u8ba1\u7b97\u6700\u5c0f\u79fb\u52a8\u6b65\u6570\n\tfor(i=1;i<=n;i++)\n\t\tsum += abs(x[i]-rex)+abs(y[i]-rey);\n\t\t\n\tprintf(\"%d\",sum);\n\t\/\/\u8f93\u51fa\u7ed3\u679c\n\treturn 0;\n } \n<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
\u6ce8\u610f\uff1a\u672c\u9875\u9762\u4e2d\u5927\u90e8\u5206\u4ee3\u7801\u90fd\u662f\u7528C++\u7f16\u5199\uff0c\u5728\u63d0\u4ea4\u65f6 …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2,5,22],"tags":[9,10],"_links":{"self":[{"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/posts\/373"}],"collection":[{"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/comments?post=373"}],"version-history":[{"count":25,"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/posts\/373\/revisions"}],"predecessor-version":[{"id":637,"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/posts\/373\/revisions\/637"}],"wp:attachment":[{"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/media?parent=373"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/categories?post=373"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sxr666.cn\/index.php\/wp-json\/wp\/v2\/tags?post=373"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}