thudaliangrx
thudaliangrx

算法竞赛入门经典(第二版)-刘汝佳-第六章 数据结构基础 习题（12/14）

说明

本文是我对第六章14道习题的练习总结，建议配合紫书——《算法竞赛入门经典（第2版）》阅读本文。
另外为了方便做题，我在VOJ上开了一个contest，欢迎一起在上面做：第六章习题contest
如果想直接看某道题，请点开目录后点开相应的题目！！！

习题

习6-1 UVA 673 平衡的括号

思路
这么简单的题目竟然错了3次，羞愧一下！注意各种细节的可能性，尤其是循环结束后stack应该为空！
给出一组测试数据，希望有帮助：
3
)
()
)(
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
using namespace std;

stack<char> st;

int main(void)
{
    int t;
    cin >> t;
    getchar();
    while (t --) {
        string s;
        getline(cin, s);
        while (st.size()) st.pop();
        bool res = true;
        for (int i = 0; i < s.size(); i ++) {
            char c = s[i];
            if (c == '(' || c == '[')
                st.push(c);
            else {
                if (st.empty() || c == ')' && st.top() != '('
                     || c == ']' && st.top() != '[') {
                    res = false;
                    break;
                } else
                    st.pop();
            }
        }
        if (res && st.empty()) puts("Yes");
        else puts("No");
    }

    return 0;
}

习6-2 UVA 712 S - 树

思路
由查询可直接计算出叶子位置，对应方法为查询的二进制数转换为10进制数，但需要注意这个题x1 x2 … xN的顺序会有所改变，还需要加一步映射。详见代码。
代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;

const int N = 7;

int n;
int order[N+1];
string leaf;

int main(void)
{
    int t = 0;
    while (cin >> n && n) {
        char s[N+1];
        for (int i = 0; i < n; i ++) {
            scanf("%s", s);
            order[i] = s[1]-'1';
        }
        cin >> leaf;

        string res;
        int k;
        cin >> k;
        while (k --) {
            scanf("%s", s);
            int m = 0;
            for (int i = 0; i < n; i ++)
                m = m*2 + s[order[i]]-'0';
            res += leaf[m];
        }
        printf("S-Tree #%d:\n", ++t);
        cout << res << endl;
        if (t) puts("");
    }

    return 0;
}

习6-3 UVA 536 二叉树重建

思路
首先可以将A-Z映射到0-25，这样数组链表就可以直接表示。
根据两个不同序遍历的重建是比较简单的，主要思想是先序和后序的根分别在最前面和最后面，然后找出根在另一个序遍历中的位置，从而知道左子树和右子树的大小，从而递归建树。
代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;

const int N = 26;

int lt[N+1], rt[N+1];

int c2d(char c)
{       
    return c - 'A' + 1;
}           

char d2c(int d)
{       
    return d - 1 + 'A';
}       

int rebuild(int n, int pre[], int in[])
{   
    if (n == 0) return 0;
    int root = pre[0];
    if (n == 1) {
        lt[root] = rt[root] = 0;
        return root;
    }
    int m;
    for (m = 0; m < n; m ++) {
        if (in[m] == root) break;
    }
    lt[root] = rebuild(m, pre+1, in);
    rt[root] = rebuild(n-m-1, pre+m+1, in+m+1);
    return root;
}

void post(int root)
{
    if (root == 0) return;
    post(lt[root]);
    post(rt[root]);
    printf("%c", d2c(root));
}

int main(void)
{
    int n;
    char s1[N+1], s2[N+1];
    int pre[N+1], in[N+1];
    while (scanf("%s%s", s1, s2) != EOF) {
        n = strlen(s1);
        for (int i = 0; i < n; i ++) {
            pre[i] = c2d(s1[i]);
            in[i] = c2d(s2[i]);
        }

        int root = rebuild(n, pre, in);
        post(root);
        printf("\n");
    }

    return 0;
}

习6-4 UVA 439 骑士的移动

思路
基本的BFS。需要注意两种特殊情况：
1、起点与终点重合的情况；
2、从起点无法到达终点的情况。
我写程序时经常容易漏掉对第一种情况的判断。
代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
using namespace std;

const int N = 8;
const int INF = 0x3f3f3f3f;

typedef pair<int, int> P;

P bg, ed;

bool legal(int x, int y)
{
    return x >= 0 && x < N && y >= 0 && y < N;
}

int BFS()
{
    int d[N][N];
    for (int i = 0; i < N; i ++)
        for (int j = 0; j < N; j ++)
            d[i][j] = INF;

    queue <P> q;
    q.push(bg);
    d[bg.first][bg.second] = 0;
    while( q.size() ) {
        P p = q.front();
        q.pop();
        int x = p.first;
        int y = p.second;

        if (p == ed)
            return d[x][y];

        int pos[8][2] = {{1, 2}, {-1, 2}, {2, 1}, {2, -1},
            {1, -2}, {-1, -2}, {-2, 1}, {-2, -1}};
        for (int i = 0; i < 8; i ++) {
            int nx = x + pos[i][0];
            int ny = y + pos[i][1];
            if (legal(nx, ny) && d[nx][ny] == INF) {
                q.push(P(nx, ny));
                d[nx][ny] = d[x][y]+1;
            }
        }
    }

    return INF;
}

int main(void)
{
    char s1[3], s2[3];
    while (~scanf("%s%s", s1, s2)) {
        bg = P(s1[0]-'a', s1[1]-'1');
        ed = P(s2[0]-'a', s2[1]-'1');

        printf("To get from %s to %s takes %d knight moves.\n", s1, s2, BFS());
    }

    return 0;
}

习6-5 UVA 1600 巡逻机器人

思路
机器人要从一个m*n（1≤m，n≤20）网格的左上角(1,1)走到右下角(m,n)。网格中的一些格子是空地（用0表示），其他格子是障碍（用1表示）。机器人每次可以往4个方向走一格，但最多连续地穿越k（0≤k≤20）个障碍，求最短路长度。起点和终点保证是空地。

此题与例6-14 UVA 816 Abbott 的复仇思路上是非常类似的，都是以三维向量标识状态。不过这个题在实现细节上要比例题要简单。
本题中(x, y, t)标识可能出现的某一状态，x表示横坐标，y表示纵坐标，t表示已经经过的障碍数，t不应当超过k。注意如果只用(x, y)来标识状态会出错。
代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;

const int N = 20;
const int INF = 0x3f3f3f3f;

int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

struct Node {
    int x, y, t;
    int d;
    Node(){}
    Node(int xx, int yy, int tt) : x(xx), y(yy), t(tt){}
};

int m, n, k;
Node mp[N+1][N+1][N+1];
int v[N+1][N+1];
Node *bg, *ed;

void init_mp()
{
    for (int x = 1; x <= m; x ++) {
        for (int y = 1; y <= n; y ++) {
            int vv = 0;
            scanf("%d", &vv);
            v[x][y] = vv;
            for (int t = 0; t <= k; t ++) {
                mp[x][y][t].x = x;
                mp[x][y][t].y = y;
                mp[x][y][t].t = t;
                mp[x][y][t].d = INF;
            }
        }
    }
    bg = &mp[1][1][0];
    ed = &mp[m][n][0];
}

bool legal(int x, int y)
{
    return x >= 1 && x <= m && y >= 1 && y <= n;
}

int BFS()
{
    queue<Node*> que;
    que.push(bg);
    bg->d = 0;

    while( que.size() ) {
        Node *p = que.front();
        que.pop();
        //printf("%d,%d,%d,%d\n", p->x, p->y, p->t, p->d);

        if (p->x == ed->x && p->y == ed->y)
            return p->d;

        for (int i = 0; i < 4; i ++) {
            int nx = p->x + dir[i][0];
            int ny = p->y + dir[i][1];
            if (legal(nx, ny)) {
                int nt = v[nx][ny] ? p->t+1 : 0;
                Node *np = &mp[nx][ny][nt];
                if (np->d == INF && np->t <= k) {
                    np->d = p->d + 1;
                    que.push(np);
                }
            }
        }
    }
    return -1;
}

int main(void)
{
    int kase;
    scanf("%d", &kase);
    while (kase--) {
        scanf("%d%d%d", &m, &n, &k);
        init_mp();

        printf("%d\n", BFS());
    }

    return 0;
}

习6-6 UVA 12166 修改天平

思路

代码

习6-7 UVA 804 Petri 网模拟

思路
题意：
你的任务是模拟Petri网的变迁。Petri网包含NP个库所（用P1，P2…表示）和NT个变迁（用T1，T2…表示）。0 < NP, NT<100。当每个变迁的每个输入库所都至少有一个token时，变迁是允许的。变迁发生的结果是每个输入库所减少一个token，每个输出库所增加一个token。变迁的发生是原子性的，即所有token的增加和减少应同时进行。注意，一个变迁可能有多个相同的输入或者输出。如果一个库所在变迁的输入库所列表中出现了两次，则token会减少两个。输出库所也是类似。如果有多个变迁是允许的，一次只能发生一个。
输入一个Petri网络。初始时每个库所都有一个token。每个变迁用一个整数序列表示，负数表示输入库所，正数表示输出库所。每个变迁至少包含一个输入和一个输出。最后输入一个整数NF，表示要发生NF次变迁（同时有多个变迁允许时可以任选一个发生，输入保证这个选择不会影响最终结果）。

解法：循环模拟，对当前库所状态搜索所有变迁，当找到符合条件的变迁时（使变迁后所有库所包含的token都不低于0），即发生变迁。输入输出细节见代码。
代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int NP = 100;
const int NT = 100;

struct Node {
    int k;
    struct Node *next;
};

int np, nt, nf;
int p[NP], p1[NP], t[NT][NP];

int main()
{
    int kase = 0;
    while (scanf("%d", &np) && np) {
        for (int i = 1; i <= np; i++)
          scanf("%d", &p[i]);
        scanf("%d", &nt);
        memset(t, 0, sizeof(t));
        for (int i = 1; i <= nt; i++) {
            int j;
            while (scanf("%d", &j) && j) {
                if (j > 0) t[i][j]++;
                else t[i][-j]--;
            }
        }
        scanf("%d", &nf);

        int f = 1;
        for (; f <= nf; f++) {
            int i;
            for (i = 1; i <= nt; i++) {
                int j;
                for (j = 1; j <= np; j++) {
                    p1[j] = p[j]+t[i][j];
                    if (p1[j] < 0) break;
                }
                if (j > np) {
                    memcpy(p, p1, sizeof(p1));
                    break;
                }
            }
            if (i > nt) break;
        }

        if (f > nf) printf("Case %d: still live ", ++kase);
        else printf("Case %d: dead ", ++kase);
        printf("after %d transitions\nPlaces with tokens:", f-1);
        for (int i = 1; i <= np; i++)
            if (p[i] > 0) printf(" %d (%d)", i, p[i]);
        printf("\n\n");
    }

    return 0;
}

习6-8 UVA 806 空间结构

思路
题意：
黑白图像有两种表示法：点阵表示和路径表示。路径表示法首先需要把图像转化为四分树，然后记录所有黑结点到根的路径。
NW、NE、SW、SE分别用1、2、3、4表示。最后把得到的数字串看成是五进制的，转化为十进制后排序。例如上面的树在转化、排序后的结果是：9 14 17 22 23 44 63 69 88 94 113。
你的任务是在这两种表示法之间进行转换。在点阵表示法中，1表示黑色，0表示白色。图像总是正方形的，且长度n为2的整数幂，并满足n≤64。输入输出细节请参见原题。

两种状态互转都需要用递归进行处理：

  1. 点阵转路径表示的情况。递归时判断当前区域包含的点是否全黑或全白，如果是则终止递归，并存储全黑叶节点对应的路径。其中递归时以字符串存储当前从根到该节点的路径。如果该区域包含的点有黑有白，则将当前区域分成4个递归处理，同时字符串加上当前路径。
  2. 路径转点阵表示的情况。递归时几乎是第一种情况的相反处理，但需要判断该节点是否是全黑叶节点，如果是则当前节点对应的区域全部置成’*’并终止递归。

另外本题需要注意一些输入输出的细节：

  1. 输出十进制时每个数字以空格分隔，但还要每12个数换行输出。
  2. 最后一个case后无空行。
    代码
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
using namespace std;

const int N = 64+1;

int n;
char area[N][N];
vector<int> nums;
set<string> strs;

bool same_color(int x0, int y0, int x1, int y1)
{
    char color0 = area[x0][y0];
    for (int i = x0; i < x1; i ++)
        for (int j = y0; j < y1; j ++)
            if (area[i][j] != color0) return false;
    return true;
}

int str2num(string s)
{
    int res = 0;
    for (int i = 0; i < s.size(); i++)
        res = res*5 + s[i]-'0';
    return res;
}

void get_nums(int x0, int y0, int x1, int y1, string s)
{
    if (same_color(x0, y0, x1, y1)) {
        if (area[x0][y0] == '1') nums.push_back(str2num(s));
        return;
    }
    int mx = (x0+x1) / 2;
    int my = (y0+y1) / 2;
    get_nums(x0, y0, mx, my, '1'+s);
    get_nums(x0, my, mx, y1, '2'+s);
    get_nums(mx, y0, x1, my, '3'+s);
    get_nums(mx, my, x1, y1, '4'+s);
}

void set_black(int x0, int y0, int x1, int y1)
{
    for (int i = x0; i < x1; i ++)
        for (int j = y0; j < y1; j ++)
            area[i][j] = '*';
}

string num2str(int num)
{
    string s;
    while (num) {
        char tmp = num%5 + '0';
        s = tmp + s;
        num /= 5;
    }
    return s;
}

void set_area(int x0, int y0, int x1, int y1, string s)
{
    if (strs.count(s)) {
        set_black(x0, y0, x1, y1);
        return;
    }
    if (x0 + 1 == x1 && y0 + 1 == y1) return;
    int mx = (x0+x1) / 2;
    int my = (y0+y1) / 2;
    set_area(x0, y0, mx, my, '1'+s);
    set_area(x0, my, mx, y1, '2'+s);
    set_area(mx, y0, x1, my, '3'+s);
    set_area(mx, my, x1, y1, '4'+s);
}

int main(void)
{
    //freopen("input", "r", stdin);
    int kase = 0;
    while (scanf("%d", &n) && n) {
        if (kase) printf("\n");
        printf("Image %d\n", ++kase);
        if (n > 0) {
            for (int i = 0; i < n; i++)
                scanf("%s", area[i]);
            nums.clear();
            get_nums(0, 0, n, n, "");
            sort(nums.begin(), nums.end());
            for (int i = 0; i < nums.size(); i++)
                printf("%d%c", nums[i], (i == nums.size()-1 || i % 12 == 11) ? '\n' : ' ');
            printf("Total number of black nodes = %d\n", nums.size());
        } else {
            n = -n;
            strs.clear();
            int x; 
            while (scanf("%d", &x) && x != -1)
                strs.insert(num2str(x));
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    area[i][j] = '.';
                }
                area[i][n] = '\0';
            }
            set_area(0, 0, n, n, "");
            for (int i = 0; i < n; i++)
                printf("%s\n", area[i]);
        }
    }

    return 0;
}

习6-9 UVA 127 纸牌游戏

思路
题意：
把52张牌从左到右排好，每张牌自成一个牌堆（pile）。当某张牌与它左边那张牌或者左边第3张牌“match”（花色suit或者点数rank相同）时，就把这张牌移到那张牌上面。移动之后还要查看是否可以进行其他移动。只有位于牌堆顶部的牌才能移动或者参与match。当牌堆之间出现空隙时要立刻把右边的所有牌堆左移一格来填补空隙。如果有多张牌可以移动，先移动最左边的那张牌；如果既可以移一格也可以移3格时，移3格。按顺序输入52张牌，输出最后的牌堆数以及各牌堆的牌数。

数据结构：用双向链表+vector数组。用链表的原因是需要删除一部分节点（当然这个题目只有52个节点，直接用顺序结构估计也可以通过）。双向链表的删除操作更容易实现，而且这个题目同时需要向前和向后访问。vector数组用来存储每一堆纸牌。

代码架构：每次从头对链表中节点进行顺序搜索，如果其左数第三个节点与其花色或点数相同，则发生纸牌移动，并重新循环；如果左数第一个相同，则发生移动并重新循环；否则继续搜索。如果搜索到链表结尾仍然没有找到符合移动条件的，说明纸牌已经无法移动。
但我的思路存在可优化的地方（只是已经AC了就懒得重新写）：发生纸牌移动后不需要从头再开始找，而是直接关注移动后的纸牌能否再次往前移动即可。
代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int N = 52;

typedef pair<char, char> P;

vector<P> pile[N+1];
int pre[N+1], next[N+1];

void init()
{
    for (int i = 1; i <= N; i++) {
        pre[i] = i-1;
        next[i-1] = i;
        pile[i].clear();
    }
    pre[0] = N;
    next[N] = 0;
}

int pre3(int u)
{
    int cnt = 3;
    while (u && cnt) {
        u = pre[u];
        cnt--;
    }
    return u;
}

bool same_top(int u, int v)
{
    P a = pile[u][pile[u].size()-1];
    P b = pile[v][pile[v].size()-1];
    return a.first == b.first || a.second == b.second;
}

void del(int u)
{
    next[pre[u]] = next[u];
    pre[next[u]] = pre[u];
}

void move_top(int u, int v)
{
    int lenu = pile[u].size();
    P a = pile[u][lenu-1];
    pile[v].push_back(a);
    pile[u].resize(lenu-1);
    if (lenu-1 == 0) del(u);
}

int main(void)
{
    char s[3];
    while (scanf("%s", s) && strcmp(s, "#")) {
        init();
        for (int i = 1; i <= N; i++) {
            if (i > 1) scanf("%s", s);
            pile[i].push_back(P(s[0], s[1]));
        }

        while (true) {
            int u = next[0];
            while (u) {
                bool flag = true;
                int v = pre3(u);
                if (v && same_top(u, v)) move_top(u, v);
                else if ((v = pre[u]) && same_top(u, v)) move_top(u, v);
                else flag = false;
                if (flag) break;
                u = next[u];
            }
            if (!u) break;
        }

        vector<int> res;
        int u = next[0];
        while (u) {
            res.push_back(pile[u].size());
            u = next[u];
        }
        if (res.size() == 1) printf("1 pile remaining:");
        else printf("%d piles remaining:", res.size());
        for (int i = 0; i < res.size(); i++)
            printf(" %d", res[i]);
        printf("\n");
    } 

    return 0;
}

习6-10 UVA 246 10-20-30

思路
题意：
给52张的扑克堆，先从左往右发7张牌，之后连续不断从左往右发7张牌，如果有牌堆形成了以下3种情况（按顺序判断）：

  1. 头两张+尾一张和为10或20或30
  2. 头一张+尾两张和为10或20或30
  3. 尾三张和为10或20或30

就把这三张牌拿走，放到总牌堆底（这步要不断执行直到不再满足条件或牌堆没了)。如果有一个牌堆因为这个操作被取完了，那么以后将不在这个位置发牌。如果最后7个牌堆都可以消掉，那么赢，总牌堆用完，那么输，否则平（即不断循环）。问最后的输赢平，并输出步数。

解法：
模拟，用一个vector记录下7个牌堆和总牌堆，这样就可以用set去记录状态了，然后每个牌堆用一个双端队列deque表示，这样满足可以从头也可以从尾巴取，不断模拟即可。

另外这个题我在做的过程中犯了两个比较大的错误：

  1. 在判断和为10或20或30时应当是循环判断，而不是只判断一次
  2. 保存当前状态时应当同时包括手中的牌和牌堆，我开始只保存了牌堆状态，结果出现了很隐蔽的错误（示例数据都能过，但是WA）

同时提供一组测试数据供参考：
INPUT

2 6 5 10 10 4 10 10 10 4 5 10 4 5 10 9 7 6 1 7 6 9 5 3 10 10 4 10 9 2 1
10 1 10 10 10 3 10 9 8 10 8 7 1 2 8 6 1 2 3 5 7
4 3 2 10 8 10 6 8 9 5 8 10 5 3 5 4 6 9 9 1 7 6 3 5 10 10 8 10 9 10 10 7 10 1 10 10 10 3 10 9 8 10 8 7 1 2 8 6 7 3 3 8
10 5 4 3 5 7 10 8 2 3 9 10 8 4 5 1 7 6 7 2 6 9 10 2 3 10 3 4 4 9 10 1 1
10 1 10 10 10 3 10 9 8 10 8 7 1 2 8 6 7 3 3 8
4 3 2 10 8 10 6 8 9 5 8 10 5 3 5 4 6 9 9 1 7 6 3 5 10 10 8 10 9 10 10 7
10 1 10 10 10 3 10 9 8 10 8 7 1 2 8 6 1 2 3
0

OUTPUT

Win : 180
Loss: 112
Loss: 118
Loss: 232

代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<deque>
#include<set>
#include<vector>
using namespace std;

typedef deque<int> PILE;
typedef vector<PILE> PILES;
PILES piles;

void init()
{
    piles.clear();
    for (int i = 0; i < 8; i++) {
        PILE p;
        piles.push_back(p);
    }
}

void solve()
{
    set<PILES> state;
    PILE& hand = piles[7];

    int cur = 0;
    while (hand.size()) {
        PILE& p = piles[cur];
        p.push_back(hand.front()); hand.pop_front();

        while (p.size() >= 3) {
            int n = p.size();
            if ((p[0]+p[1]+p[n-1]) % 10 == 0) {
                hand.push_back(p[0]);
                hand.push_back(p[1]);
                hand.push_back(p[n-1]);
                p.pop_front();
                p.pop_front();
                p.pop_back();
            } else if ((p[0]+p[n-2]+p[n-1]) % 10 == 0) {
                hand.push_back(p[0]);
                hand.push_back(p[n-2]);
                hand.push_back(p[n-1]);
                p.pop_front();
                p.pop_back();
                p.pop_back();
            } else if ((p[n-3]+p[n-2]+p[n-1]) % 10 == 0) {
                hand.push_back(p[n-3]);
                hand.push_back(p[n-2]);
                hand.push_back(p[n-1]);
                p.pop_back();
                p.pop_back();
                p.pop_back();
            } else break;
        }

        if (hand.size() == 52) {
            printf("Win : %d\n", state.size()+8);
            return;
        }

        if (hand.empty()) {
            printf("Loss: %d\n", state.size()+8);
            return;
        }

        if (state.count(piles)) {
            printf("Draw: %d\n", state.size()+8);
            return;
        }

        state.insert(piles);
        do {
            cur = (cur+1)%7;
        } while (piles[cur].empty());
    }
}

int main()
{
    int num;
    while (scanf("%d", &num) && num) {
        init(); 
        PILE& hand = piles[7];
        hand.push_back(num);
        for (int i = 0; i < 51; i++) {
            scanf("%d", &num);
            hand.push_back(num);
        }       
        for (int i = 0; i < 7; i++) {
            piles[i].push_back(hand.front()); hand.pop_front();
        }       

        solve();
    }       

    return 0;
}

习6-11 UVA 10410 树重建

思路
题意：
输入一个n（n≤1000）结点树的BFS序列和DFS序列，你的任务是输出每个结点的子结点列表。输入序列（不管是BFS还是DFS）是这样生成的：当一个结点被扩展时，其所有子结点应该按照编号从小到大的顺序访问。

本以为与二叉树根据两种遍历重建树的过程完全类似，试了一下才发现大相径庭。
在反复推演后，形成了本题的思路：
基于BFS序列按层遍历，对于该层的节点在进行顺序访问时，应当在DFS序列中顺序相同（但可能中间隔着其它节点），一旦BFS中的节点在DFS中找不到对应的，说明已经到达树的下一层。
按层遍历BFS序列时，其上层节点序列已经存储到set < int > upper中，访问该层的节点时，寻找其在DFS序列中向前找最近的出现在upper中的节点，这就是其父节点，将该节点归入其父节点的孩子集合中。
最后对每个节点输出其孩子集合即可。

此题网上还有很多其他解法，有兴趣的读者请参考其他博客。
代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;

const int N = 1001;

int n;
int bfs[N], dfs[N];
vector<int> children[N];

void get_tree()
{
    set<int> upper;
    upper.insert(bfs[1]);
    int begin = 2, i, j;
    while (begin <= n) {
        i = begin;
        j = 2;
        for (; i <= n; i++) {
            for (; j <= n; j++)
                if (dfs[j] == bfs[i]) break;
            if (j > n) break;
            for (int k = j-1; k >= 1; k--) {
                if (upper.count(dfs[k])) {
                    children[dfs[k]].push_back(bfs[i]);
                    break;
                }
            }
        }
        upper.clear();
        for (int k = begin; k < i; k++)
            upper.insert(bfs[k]);
        begin = i;
    }
}

int main(void)
{
    while (scanf("%d", &n) != EOF) {
        for (int i = 1; i <= n; i++)
            scanf("%d", &bfs[i]);
        for (int i = 1; i <= n; i++)
            scanf("%d", &dfs[i]);

        for (int i = 1; i <= n; i++)
            children[i].clear();
        get_tree();
        for (int i = 1; i <= n; i++) {
            printf("%d:", i);
            for (int j = 0; j < children[i].size(); j++)
                printf(" %d", children[i][j]);
            printf("\n");
        }
    }

    return 0;
}

习6-12 UVA 810 筛子难题

思路
题意是给出一个图，每个格子上都有一个数。然后给出一个起始位置，往这个位置上放一个骰子。然后给出这个骰子的初始状态，骰子的状态由两个数字表示，分别代表骰子顶面和正前面（从二维地图从下向上看为正前）的点数。如果骰子所在格子的相邻格子的数字等于当前骰子顶面的点数相同或者-1，那么骰子就可以滚动到这个格子上，如果格子的数字为0则表示该格子无法到达。要求求出一条路，使得骰子从起点出发能再走回起点，如果不存在，输出“No Solution Possible”。

其实就是个四维状态BFS，每个状态(x, y, t, f)表示(横坐标, 纵坐标, 顶面数字, 正前面数字)。实际山给定顶面数字和正前面数字就唯一的确定了一个筛子的状态。四个方向（上下左右）的翻滚中，左翻和右翻需要用打表法确定下一个状态。
另外本题的输出格式略显复杂，详见代码。
代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;

const int N = 10;
const int INF = 0x3f3f3f3f;

int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; //下右上左
int r[7][7];

struct Node {
    int x, y, t, f;
    int d;
    Node *pre;
};

int m, n;
Node mp[N+1][N+1][6+1][6+1];
int v[N+1][N+1];
Node *bg;

void init_right()
{
    memset(r, 0, sizeof(r));
    r[6][2] = r[2][1] = r[1][5] = r[5][6] = 4;
    r[6][5] = r[5][1] = r[1][2] = r[2][6] = 3;
    r[6][3] = r[3][1] = r[1][4] = r[4][6] = 2;
    r[6][4] = r[4][1] = r[1][3] = r[3][6] = 5;
    r[3][2] = r[2][4] = r[4][5] = r[5][3] = 6;
    r[3][5] = r[5][4] = r[4][2] = r[2][3] = 1;
}

void init_mp()
{
    for (int x = 1; x <= m; x ++) {
        for (int y = 1; y <= n; y ++) {
            scanf("%d", &v[x][y]);
            for (int t = 1; t <= 6; t ++) {
                for (int f = 1; f <= 6; f ++) {
                    mp[x][y][t][f].x = x;
                    mp[x][y][t][f].y = y;
                    mp[x][y][t][f].t = t;
                    mp[x][y][t][f].f = f;
                    mp[x][y][t][f].d = INF;
                    mp[x][y][t][f].pre = NULL;
                }
            }
        }
    }
}

bool legal(int x, int y)
{
    return x >= 1 && x <= m && y >= 1 && y <= n;
}

Node *BFS()
{
    queue<Node*> que;
    que.push(bg);
    bg->d = 0;

    bool first = true;
    while( que.size() ) {
        Node *p = que.front();
        que.pop();
        //printf("%d,%d,%d,%d\n", p->x, p->y, p->t, p->d);

        if (!first) {
            if (p->x == bg->x && p->y == bg->y)
                return p;
        } else
            first = false;

        for (int i = 0; i < 4; i ++) {
            int nx = p->x + dir[i][0];
            int ny = p->y + dir[i][1];
            if (legal(nx, ny) && (v[nx][ny] == -1 || v[nx][ny] == p->t)) {
                int nt, nf, t = p->t, f = p->f;
                if (i == 0) { //down
                    nt = 7-f; nf = t;
                } else if (i == 1) { //right
                    nt = 7-r[t][f]; nf = f;
                } else if (i == 2) { //up
                    nt = f; nf = 7-t;
                } else if (i == 3) { //left
                    nt = r[t][f]; nf = f;
                }
                Node *np = &mp[nx][ny][nt][nf];
                if (np->d == INF || np == bg) {
                    np->d = p->d + 1;
                    np->pre = p;
                    que.push(np);
                }
            }
        }
    }
    return NULL;
}

int main(void)
{   
    init_right();

    char name[21];
    while (scanf("%s", name) && strcmp(name, "END")) {
        int bx, by, bt, bf;
        scanf("%d%d%d%d%d%d", &m, &n, &bx, &by, &bt, &bf);
        init_mp();
        bg = &mp[bx][by][bt][bf];

        printf("%s\n", name);
        Node *p = BFS();
        if (p == NULL) printf(" No Solution Possible\n");
        else {
            typedef pair<int, int> P;
            vector<P> path; 
            while (p->pre != bg) {
                path.push_back(P(p->x, p->y)); 
                p = p->pre; 
            }   
            path.push_back(P(p->x, p->y));
            path.push_back(P(bg->x, bg->y));
            for (int i = path.size()-1; i >= 0; i--) {
                if ((path.size()-i)%9 == 1) printf(" ");
                printf("(%d,%d)", path[i].first, path[i].second);
                if (i != 0) printf(",");
                if ((path.size()-i)%9 == 0 || i == 0) printf("\n");
            }
        }
    }

    return 0;
}

习6-13 UVA 215 电子表格计算器

思路
题意：
在一个R行C列（R≤20，C≤10）的电子表格中，行编号为A～T，列编号为0～9。按照行优先顺序输入电子表格的各个单元格。每个单元格可能是整数（可能是负数）或者引用了其他单元格的表达式（只包含非负整数、单元格名称和加减号，没有括号）。表达式保证以单元格名称开头，内部不含空白字符，且最多包含75个字符。
尽量计算出所有表达式的值，然后输出各个单元格的值（计算结果保证为绝对值不超过10000的整数）。如果某些单元格循环引用，在表格之后输出（仍按行优先顺序）。

表格的引用类似于拓扑排序过程，如果出现循环引用则说明拓扑上存在圈。本来直接用书中例题的拓扑排序能解，但本题还要求输出所有无法计算的单元格，这个就需要对书中的排序算法做一点扩展，详见code。

这个题上折腾了挺长时间，为了帮助大家调试，特提供一组测试数据：
INPUT

1 1
A0-A0
4 4
A1-A2+A3
A2
A3
B1+6
A3
4
A3-A2+6
B2+7-15+B1
1
2
3
4
C1-C3-C3-C3-15-C3
8
5
6
3 3
A1
A2
B0
B1
B2
C0
C1
C2
A0
3 3
A1
A2
B0
B1
B2
6
A1
C2
A1
6 6
1
A2
A0
C2
C4+C5+C2
B4-B3
2
A1
A1
A1
B0
B1
3
D5-C0+4
A2+B6-C0+E5+5
4
5
6
4
1
5
10
15
20
5
A2
A2
A2
A2
A3
6
B4
4
5
6
7
6 6
1
A2
A0
C2
C4+C5+C2
B4-B3
2
A1
A1
A1
B0
B1
3
D5-C0+4
A2+B5-C0+E5+5
4
5
6
4
1
5
10
15
20
5
A2
A2
A2
A2
A0
6
B4
4
5
6
7
0 0

OUTPUT

A0: A0-A0

 0 1 2 3 A 10 10 10 10 B 10 4 6 2 C 1 2 3 4 D -29 8 5 6 A0: A1 A1: A2 A2: B0 B0: B1 B1: B2 B2: C0 C0: C1 C1: C2 C2: A0 0 1 2 A 6 6 6 B 6 6 6 C 6 6 6 A3: C2 A4: C4+C5+C2 C2: A2+B6-C0+E5+5 E5: A3 0 1 2 3 4 5 A 1 1 1 5 16 1 B 2 1 1 1 2 1 C 3 21 5 4 5 6 D 4 1 5 10 15 20 E 5 1 1 1 1 1 F 6 2 4 5 6 7

代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int ROW = 20;
const int COL = 10;
const int N = ROW*COL;
const int MAX = 10000;

int row, col;
string tab[ROW][COL];

int n;
int c[N];
int val[N];
typedef pair<int, int> P;
vector<P> dep[N];

void prase_str(int i, int j)
{
    int k = i*col+j;
    string& s = tab[i][j];
    val[k] = 0;
    dep[k].clear();
    if (!isalpha(s[0])) {
        val[k] = atoi(s.c_str());
    } else {
        for (int h = 0; h < s.size(); h++) {
            if (isalpha(s[h]) || s[h] == '-' || s[h] == '+') {
                int sign = 1;
                if (s[h] == '-' || s[h] == '+') {
                    if (s[h] == '-') sign = -1;
                    h++;
                }
                if (isalpha(s[h]))
                  dep[k].push_back(P(sign, (s[h]-'A')*col + s[h+1]-'0'));
                else
                  val[k] += sign * atoi(s.substr(h).c_str());
            }
        }
    }
}

int dfs(int k)
{
    c[k] = -1;
    if (val[k] >= MAX) return MAX;
    for (int i = 0; i < dep[k].size(); i++) {
        int sign = dep[k][i].first;
        int u = dep[k][i].second;
        int v = 0;
        if (c[u] < 0 || (v = dfs(u)) >= MAX)
            return val[k] = MAX;
        val[k] += sign*v;
    }
    c[k] = 1;
    dep[k].clear();
    return val[k];
}

void toposort()
{
    memset(c, 0, sizeof(c));
    for (int i = 0; i < n; i++)
        dfs(i);
}

bool check_val()
{
    for (int i = 0; i < n; i++)
        if (val[i] >= MAX) return false;
    return true;
}

int main(void)
{
    //freopen("input", "r", stdin);
    while (scanf("%d%d", &row, &col), row || col) {
        n = row*col;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                cin >> tab[i][j];
                prase_str(i, j);
            }
        }

        toposort();
        if (check_val()) {
            printf(" ");
            for (int j = 0; j < col; j++)
              printf("%6d", j);
            printf("\n");
            for (int i = 0; i < row; i++) {
                printf("%c", i+'A');
                for (int j = 0; j < col; j++) {
                    printf("%6d", val[i*col+j]);
                }
                printf("\n");
            }
        } else {
            for (int i = 0; i < row; i++) {
                for (int j = 0; j < col; j++) {
                    if (val[i*col+j] >= MAX) {
                        printf("%c%c: ", i+'A', j+'0');
                        cout << tab[i][j] << endl;
                    }
                }
            }
        }
        printf("\n");
    }

    return 0;
}

习6-14 UVA 12118 检察员的难题

思路

代码

你可能感兴趣的:(数据结构,算法,ACM,uva,算法竞赛入门经典)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
    ?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 最超值的Mac——Mac mini 初心么么哒
    你知道最超值的Mac是什么吗？自2005年以来，Macmini一直是Apple台式机产品线中的主要产品。最初推出是为了让对Mac好奇的Mac进入Apple生态系统的一种简单方式，现在新的AppleSiliconMacmini可能是任何寻找新Mac的人的最有吸引力的购买。什么是AppleSiliconMacmini？M1Macmini是Apple最小的台式电脑，同时也是最快的台式电脑之一。最新型号由
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • Python算法L5：贪心算法 小熊同学哦 Python算法算法python贪心算法
    Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 非对称加密算法原理与应用2——RSA私钥加密文件 私语茶馆 云部署与开发架构及产品灵感记录RSA2048私钥加密
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • 粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能matlab算法
    在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 非对称加密算法————RSA理论及详情 hu19930613
    转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
  • jdk tomcat 环境变量配置 Array_06 javajdktomcat
    Win7 下如何配置java环境变量 1。准备jdk包，win7系统，tomcat安装包（均上网下载即可） 2。进行对jdk的安装，尽量为默认路径（但要记住啊！！以防以后配置用。。。） 3。分别配置高级环境变量。   电脑-->右击属性-->高级环境变量-->环境变量。 分别配置 : path    &nbs
  • Spring调SDK包报java.lang.NoSuchFieldError错误 bijian1013 javaspring
            在工作中调另一个系统的SDK包，出现如下java.lang.NoSuchFieldError错误。 org.springframework.web.util.NestedServletException: Handler processing failed; nested exception is java.l
  • LeetCode[位运算] - #136 数组中的单一数 Cwind java题解位运算LeetCodeAlgorithm
    原题链接：#136 Single Number 要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现两次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 难度：中等 分析： 题目限定了线性的时间复杂度，同时不使用额外的空间，即要求只遍历数组一遍得出结果。由于异或运算 n XOR n = 0, n XOR 0 = n，故将数组中的每个元素进
  • qq登陆界面开发 15700786134 qq
    今天我们来开发一个qq登陆界面，首先写一个界面程序，一个界面首先是一个Frame对象，即是一个窗体。然后在这个窗体上放置其他组件。代码如下： public class First {         public void initul(){        jf=ne
  • Linux的程序包管理器RPM 被触发 linux
    在早期我们使用源代码的方式来安装软件时，都需要先把源程序代码编译成可执行的二进制安装程序，然后进行安装。这就意味着每次安装软件都需要经过预处理-->编译-->汇编-->链接-->生成安装文件--> 安装，这个复杂而艰辛的过程。为简化安装步骤，便于广大用户的安装部署程序，程序提供商就在特定的系统上面编译好相关程序的安装文件并进行打包，提供给大家下载，我们只需要根据自己的
  • socket通信遇到EOFException 肆无忌惮_ EOFException
    java.io.EOFException at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2281) at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:
  • 基于spring的web项目定时操作 知了ing javaWeb
    废话不多说，直接上代码，很简单 配置一下项目启动就行 1，web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="h
  • 树形结构的数据库表Schema设计 矮蛋蛋 schema
    原文地址： http://blog.csdn.net/MONKEY_D_MENG/article/details/6647488     程序设计过程中，我们常常用树形结构来表征某些数据的关联关系，如企业上下级部门、栏目结构、商品分类等等，通常而言，这些树状结构需要借助于数据库完成持久化。然而目前的各种基于关系的数据库，都是以二维表的形式记录存储数据信息，
  • maven将jar包和源码一起打包到本地仓库 alleni123 maven
    http://stackoverflow.com/questions/4031987/how-to-upload-sources-to-local-maven-repository <project> ... <build> <plugins> <plugin> <groupI
  • java IO操作 与 File 获取文件或文件夹的大小，可读，等属性！！！ 百合不是茶
    类 File File是指文件和目录路径名的抽象表示形式。 1，何为文件： 标准文件（txt doc mp3...） 目录文件（文件夹） 虚拟内存文件   2，File类中有可以创建文件的 createNewFile（）方法,在创建新文件的时候需要try{} catch(）{}因为可能会抛出异常；也有可以判断文件是否是一个标准文件的方法isFile();这些防抖都
  • Spring注入有继承关系的类（2） bijian1013 javaspring
    被注入类的父类有相应的属性，Spring可以直接注入相应的属性，如下所例：1.AClass类 package com.bijian.spring.test4; public class AClass { private String a; private String b; public String getA() { retu
  • 30岁转型期你能否成为成功人士 bijian1013 成长励志
            很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
  • 【Velocity四】Velocity与Java互操作 bit1129 velocity
    Velocity出现的目的用于简化基于MVC的web应用开发，用于替代JSP标签技术，那么Velocity如何访问Java代码.本篇继续以Velocity三http://bit1129.iteye.com/blog/2106142中的例子为基础，      POJO    package com.tom.servlets; public
  • 【Hive十一】Hive数据倾斜优化 bit1129 hive
    什么是Hive数据倾斜问题   操作：join,group by,count distinct 现象：任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成；查看未完成的子任务，可以看到本地读写数据量积累非常大，通常超过10GB可以认定为发生数据倾斜。 原因：key分布不均匀 倾斜度衡量：平均记录数超过50w且
  • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua csrf
    Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
  • java-3.求子数组的最大和 bylijinnan java
    package beautyOfCoding; public class MaxSubArraySum { /** * 3.求子数组的最大和 题目描述： 输入一个整形数组，数组里有正数也有负数。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值。要求时间复杂度为O(n)。 例如输入的数组为1, -2, 3, 10, -4,
  • Netty源码学习-FileRegion bylijinnan javanetty
    今天看org.jboss.netty.example.http.file.HttpStaticFileServerHandler.java 可以直接往channel里面写入一个FileRegion对象，而不需要相应的encoder： //pipeline（没有诸如“FileRegionEncoder”的handler）： public ChannelPipeline ge
  • 使用ZeroClipboard解决跨浏览器复制到剪贴板的问题 cngolon 跨浏览器复制到粘贴板Zero Clipboard
    Zero Clipboard的实现原理 Zero Clipboard 利用透明的Flash让其漂浮在复制按钮之上，这样其实点击的不是按钮而是 Flash ，这样将需要的内容传入Flash，再通过Flash的复制功能把传入的内容复制到剪贴板。 Zero Clipboard的安装方法 首先需要下载 Zero Clipboard的压缩包，解压后把文件夹中两个文件：ZeroClipboard.js
  • 单例模式 cuishikuan 单例模式
    第一种（懒汉，线程不安全）： public class Singleton {   2     private static Singleton instance;   3     pri
  • spring+websocket的使用 dalan_123
    一、spring配置文件 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.or
  • 细节问题：ZEROFILL的用法范围。 dcj3sjt126com mysql
    1、zerofill把月份中的一位数字比如1，2，3等加前导0 mysql> CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL,    -> day
  • Android开发10——Activity的跳转与传值 dcj3sjt126com Android开发
    Activity跳转与传值，主要是通过Intent类，Intent的作用是激活组件和附带数据。   一、Activity跳转 方法一Intent intent = new Intent(A.this, B.class); startActivity(intent)   方法二Intent intent = new Intent();intent.setCla
  • jdbc 得到表结构、主键 eksliang jdbc 得到表结构、主键
    转自博客：http://blog.csdn.net/ocean1010/article/details/7266042 假设有个con DatabaseMetaData dbmd = con.getMetaData(); rs = dbmd.getColumns(con.getCatalog(), schema, tableName, null); rs.getSt
  • Android 应用程序开关GPS gqdy365 android
    要在应用程序中操作GPS开关需要权限： <uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" /> 但在配置文件中添加此权限之后会报错，无法再eclipse里面正常编译，怎么办？ 1、方法一：将项目放到Android源码中编译； 2、方法二：网上有人说cl
  • Windows上调试MapReduce zhiquanliu mapreduce
    1.下载hadoop2x-eclipse-plugin https://github.com/winghc/hadoop2x-eclipse-plugin.git 把 hadoop2.6.0-eclipse-plugin.jar 放到eclipse plugin 目录中。 2.下载 hadoop2.6_x64_.zip http://dl.iteye.com/topics/download/d2b
  • 如何看待一些知名博客推广软文的行为？ justjavac 博客
    本文来自我在知乎上的一个回答：http://www.zhihu.com/question/23431810/answer/24588621 互联网上的两种典型心态： 当初求种像条狗，如今撸完嫌人丑 当初搜贴像条犬，如今读完嫌人软 你为啥感觉不舒服呢？ 难道非得要作者把自己的劳动成果免费给你用，你才舒服？ 就如同 Google 关闭了 Gooled Reader，那是
  • sql优化总结 macroli sql
    为了是自己对sql优化有更好的原则性，在这里做一下总结，个人原则如有不对请多多指教。谢谢！   要知道一个简单的sql语句执行效率，就要有查看方式，一遍更好的进行优化。   一、简单的统计语句执行时间 declare @d datetime ---定义一个datetime的变量set @d=getdate() ---获取查询语句开始前的时间select user_id
  • Linux Oracle中常遇到的一些问题及命令总结 超声波 oraclelinux
    1.linux更改主机名   (1)#hostname oracledb　　　　临时修改主机名 (2) vi /etc/sysconfig/network 　　修改hostname (3) vi /etc/hosts　　　　　　　　修改IP对应的主机名   2.linux重启oracle实例及监听的各种方法 （注意操作的顺序应该是先监听，后数据库实例） &nbs
  • hive函数大全及使用示例 superlxw1234 hadoophive函数
      具体说明及示例参 见附件文档。     文档目录：   目录 一、关系运算： 4 1. 等值比较: = 4 2. 不等值比较: <> 4 3. 小于比较: < 4 4. 小于等于比较: <= 4 5. 大于比较: > 5 6. 大于等于比较: >= 5 7. 空值判断: IS NULL 5
  • Spring 4.2新特性-使用@Order调整配置类加载顺序 wiselyman spring 4
    4.1 @Order Spring 4.2 利用@Order控制配置类的加载顺序 4.2 演示 两个演示bean package com.wisely.spring4_2.order; public class Demo1Service { } package com.wisely.spring4_2.order; public class
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他