snowy_smile

2019 ICPC 上海 M Blood Pressure Game [血压游戏] 出题人原封不动标程

忘记贴个中文题面了~~

作为前来上海大学参加ICPC比赛的退役ACMer现役JBer，小明每次来上海大学参加比赛，都会打铁。心里就会产生一种"这是什么JB比赛"的念头。为了排解痛苦，他就会去上海的迪士尼坐过山车。他很喜欢这种血压拉满的感觉，让他感觉自己如同变成了一只"快乐"的Flappy Bird，忘记了所有的WA和TLE……
过山车有一系列的高低起伏的转折点，各个转折点的高度，按照路径顺序形成了一个数列a[]，小明坐完所有过山车后，他的血压可以认为是Σ(|a[i + 1] - a[i]|)，即相邻过山车高度的绝对值之和。
小明比赛一直打铁，一直打铁，于是一直需要不停地坐过山车，然而，可以使得他忘记烦恼的所需血压阈值也在慢慢上升。渐渐地，上海迪士尼的过山车，已经达不到小明对自己血压的要求了。
因此，小明开始设想增加额外的m个转折点b[]，以任意的位置和顺序（此处需要讨论具体规则），加入原有的过山车的路径a[]中，让自己的血压拉得尽可能高。
请计算一下，小明的血压最高可以变成多少呢？这非常重要。我们需要这个数据来请一位适合的心血管内科医生。救救小明吧！您的AC非常重要！

再反手给一个知乎的原问题链接 ——

https://www.zhihu.com/question/355256075/answer/907869387

当然，事情前前后后的链接可多了2333 ~

以下内容的发表时间是 —— 2019年11月25日 20:30:07

血压游戏，实质名归好吧233333~
代码时间是 2019-11-23 18:34:27一个标点符号我都没有修改，贴在这里了。

询问了出题组包括bin巨，他们同意我把标程发过来。
不排除有错误，我觉得很有可能会被发现哪里写得有问题，但是能学到知识不是美滋滋吗 ~
而且确实，在我看来，就与我写了更优复杂度的标程没什么区别，除了n的设置外，没有影响比赛结果。问心无愧。

// #include 
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define FMS(x, y, g) memset(x, y, sizeof(x[0]) * (g))
typedef long long LL;

// Variables For the Specific Problem
const bool GUESS = false;                // 是否验证一些猜想（如点数、边数等）的开关
const bool DEBUG = false;               // 是否输出细节（用于调试）的开关
// control variables end
const LL INF = 1e16;                    // 表示两点之前的极大收益 [1E9是不够的哦]
const int E9 =  1e9;                    // 就表示 1E9
const int G = 100000;                     // 题目设置的数组长度
const int N = G * 4 + 99;               // 点数 4n 级别
const int M = G * 10 * 2 + 99;          // 边数 10n 级别
int n, m;                               // n 表示原始数组 a 的大小，m 表示可插入集合 b 的大小
int a[N], b[N];                         // 待插入数组 a, 可插入集合 b
int casenum, casei;                     // 数据组数 casenum, 当前数据编号 casei
// End

// 把 a 或 b 的信息整合一起的数据类型
struct Ele
{
    int tp, id;
    int l, r;
    Ele(){};
    Ele(int tp_, int id_, int l_, int r_) {
        tp = tp_; id = id_; l = l_; r = r_;
    };
};
// 按照左界下降排序
bool cmpL(Ele a, Ele b) {
    if(a.l != b.l)return a.l > b.l;
    return a.tp > b.tp;
}
// 按照右界上升排序
bool cmpR(Ele a, Ele b) {
    if(a.r != b.r)return a.r < b.r;
    return a.tp > b.tp;
}

// 费用流
struct wkcMCMF {
    int ST, ED;                             // 源点与汇点(我习惯上使得ST=0,ED=最后一个点的编号)
    int first[N], ID;                       // 边集的起点边编号(ID初始化为1，表示新分配的边的编号)
    int w[M], cap[M], cost[M], nxt[M];	    // 边包括了（抵达点w，容量cap，单位流量成本cost，下条边编号nxt）等信息
    LL f[N];							    // f[x]表示在残量网络下，从源点到达x的最小距离
    int pe[N];							    // pe[x]记录流向x的前驱边
    bool e[N];							    // e[x]是判定点x是否在SPFA队列中的辅助数组
    queue q;                           // q是SPFA的队列
    int SUM;                                // 用于检查程序正确性——求最终血压值

    // 加边
    void ins(int x, int y, int cap_, LL cost_) {
        w[++ID] = y;
        cap[ID] = cap_;
        cost[ID] = cost_;
        nxt[ID] = first[x];
        first[x] = ID;
        w[++ID] = x;
        cap[ID] = 0;
        cost[ID] = -cost_;
        nxt[ID] = first[y];
        first[y] = ID;
    }

    // 入队
    void inq(int x, LL cost_, int pe_) {
        if (cost_ <= f[x])return;           // 单位流量收益更小，没有更新意义
        f[x] = cost_;                       // 单位流量收益大的条件下做更新
        pe[x] = pe_;                        // 然后记录上一条边
        if (x == ED || e[x])return;         // SPFA的入队标记以防止重复入队做冗余更新
        e[x] = true;
        q.push(x);
    }

    // SPFA找最长路（最高收益）
    int Augmenting = 1;                     // 表示具有增广意义的最低增广收益值，可能会有调整为 1 或者 0 的需要
    bool spfa() {                           // 返回值为true表示找到了一条成功的增广路
        FMS(f, -63, ED + 2);         // 初始的收益值一定要设置为极小 [-1似乎是不够的]
        cap[0] = E9;
        inq(ST, 0, 0);
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            e[x] =  0;
            for (int z = first[x]; z; z = nxt[z]) {
                if (cap[z])inq(w[z], f[x] + cost[z], z);
            }
        }
        return f[ED] >= Augmenting;         // 收益 < Augmenting 之后的增广便不再有意义了
    }

    // 从终点滚到起点，确定此费用下的最大流量，并修改残余流量 [单路回溯的普通写法]
    vectorslowMCMF(LL basic) {
        vectorrtn;
        int maxflow = 0;
        LL mincost = basic;
        while (spfa()) {
            int flow = E9;
            int x = ED;
            while (x != ST) {
                flow = min(flow, cap[pe[x]]);
                x = w[pe[x] ^ 1];
            }
            maxflow += flow;
            x = ED;
            while (x != ST) {
                cap[pe[x]] -= flow;
                cap[pe[x] ^ 1] += flow;
                x = w[pe[x] ^ 1];
            }
            for(int i = 1; i <= flow; ++i) {
                mincost += f[ED];
                rtn.push_back(mincost);
            }
        }
        while(rtn.size() < m) {
            rtn.push_back(mincost);
        }
        return rtn;
    }

    // 高效费用流所使用的DFS多路回溯算法
    bool vis[N];
    int dfs(int x, int all) {
        if (x == ST)return all;
        int use = 0;
        vis[x] = true;
        for (int z = first[x]; z; z = nxt[z])
            if (cap[z ^ 1]) {
                int y = w[z];
                if (!vis[y] && f[y] + cost[z ^ 1] == f[x]) {
                    int tmp = dfs(y, min(cap[z ^ 1], all - use));
                    cap[z ^ 1] -= tmp;
                    cap[z] += tmp;
                    use += tmp;
                    if (use == all)break;
                }
            }
        return use;
    }

    // 从终点滚到起点，确定此费用下的最大流量，并修改残余流量 [多路回溯的DFS高效写法]
    vector fastMCMF(LL basic) {
        vectorrtn;
        int maxflow = 0;
        LL mincost = basic;
        while (spfa()) {
            int flow;
            while (FMS(vis, 0, ED + 2),
                    flow = dfs(ED, E9)) {
                maxflow += flow;
                for(int i = 1; i <= flow; ++i) {
                    mincost += f[ED];
                    rtn.push_back(mincost);
                }
            }
        }
        while(rtn.size() < m) {
            rtn.push_back(mincost);
        }
        return rtn;
    }

    // ST = 0
    // added point [1, m]
    // up segment point [m + 1, m + n)
    // down segment point [m + n + 1, m + n + n)
    // final [m + n + n + 0, m + n + n + n]
    // ED = m + n * 3 + 1
    Ele ele[N];
    maprkL;                   // 记录每个左界区间对应的排名(start from 1)
    maprkR;                   // 记录每个右界区间对应的排名(start from 1)
    pairvaL[N];               // sorted L list (vaL, id) down
    pairvaR[N];               // sorted R list (vaR, id) up
    int pos[N];                         // a to b, record the ans
    vectoransVec;                  // ans vector
    void NplusM_mapBuild() {
        ID = 1;
        ST = 0;
        ED = m + n * 3 + 1;
        int eg = 0;
        for (int i = 1; i <= m; ++i) {
            ele[++eg].tp = 1;
            ele[eg].id = i;
            ele[eg].l = ele[eg].r = b[i];
        }
        for (int i = 1; i < n; ++i) {
            ele[++eg].tp = 2;
            ele[eg].id = i;
            ele[eg].l = min(a[i], a[i + 1]);
            ele[eg].r = max(a[i], a[i + 1]);
        }
        rkL.clear();
        rkR.clear();
        // point -> bigger segment [L decreasing order]
        // 从区间 [l[i + 1], r[i + 1]] 向区间 [l[i], r[i]] 连一条容量极大(>=m即可)，收益为(l[i] - l[i + 1]) * 2的边 <此处n - 2条边>
        int lastId = E9;
        int lastV;
        int oL = 0;
        sort(ele + 1, ele + eg + 1, cmpL);
        for(int i = 1; i <= eg; ++i) {
            if(ele[i].tp == 2) {
                int eid = ele[i].id + m;
                if(lastId != E9) {
                    ins(eid, lastId, E9, (lastV - ele[i].l) << 1);
                }
                lastId = eid;
                lastV = ele[i].l;
                vaL[++oL] = {lastV, ele[i].id};
                rkL[lastV] = oL;
            }
            else if(lastId != E9) {
                // 向比其大的第一个(如果存在) "下匹配的左界区间[l, r]", 连一条容量为1(>=1即可)，收益为(l - v) * 2的边
                ins(ele[i].id, lastId, 1, (lastV - ele[i].l) << 1);
            }
        }
        if (DEBUG) {
            printf("rkL(v,g): ");
            for(auto &it : rkL)printf("[%d %d] ", it.first, it.second);
            puts("");
        }
        // point -> smaller segment [R increasing order]
        // 从区间 [l[i + 1], r[i + 1]] 向区间 [l[i], r[i]] 连一条容量极大(>=m即可)，收益为(r[i + 1] - r[i]) * 2的边 <此处n - 2条边>
        lastId = E9;
        int oR = 0;
        sort(ele + 1, ele + eg + 1, cmpR);
        for (int i = 1; i <= eg; ++i) {
            if (ele[i].tp == 2) {
                int eid = ele[i].id + m + n;
                if(lastId != E9) {
                    ins(eid, lastId, E9, (ele[i].r - lastV) << 1);
                }
                lastId = eid;
                lastV = ele[i].r;
                vaR[++oR] = {lastV, ele[i].id};
                rkR[lastV] = oR;
            }
            else if (lastId != E9) {
                // 向比其大的第一个(如果存在) "下匹配的左界区间[l, r]", 连一条容量为1(>=1即可)，收益为(v - r) * 2的边
                ins(ele[i].id, lastId, 1, (ele[i].r - lastV) << 1);
            }
        }
        if (DEBUG) {
            printf("rkR(v,g): ");
            for(auto &it : rkR)printf("[%d %d] ", it.first, it.second);
            puts("");
        }
        // 从 m 个插入点向首尾 2 个特殊插入位置连一条容量为1(>=1即可)，收益为0的边 <此处m * 2条边>
        for (int i = 1; i <= m; ++i) {
            ins(i, m + n + n + 0, 1, abs(b[i] - a[1]));
            ins(i, m + n + n + n, 1, abs(b[i] - a[n]));
        }
        // 源点连接 m 个被插入点[1, m], 容量统一为1，收益统一为0 <此处m条边>
        for (int i = 1; i <= m; ++i) {
            ins(ST, i, 1, 0);
        }
        // 下匹配左区间点 & 上匹配右区间点 -> 真实区间点 <此处(n-1)*2条边>
        for (int i = 1; i < n; ++i) {
            ins(m + i, m + n + n + i, 1, 0);
            ins(m + n + i, m + n + n + i, 1, 0);
        }
        // 真实区间点 [m + n + n + 0, m + n + n + n] 向汇点 ED 连一条容量为1，收益为0的边 <此处n + 1条边>
        for (int i = 0; i <= n; ++i) {
            ins(m + n + n + i, ED, 1, 0);
        }
    }

    // 根据网络流的流量情况构造解
    int from[N];                    // 记录每个实际的区间a是作为上升区间还是下降区间被匹配的
    void NplusM_output() {
        setAnyPosOK_bset;
        for (int i = 1; i <= m; ++i) {
            AnyPosOK_bset.insert(b[i]);
        }
        vectorLbTOa;
        vectorRbTOa;
        for (int y = 0; y <= n; ++y) {
            // check[m + 1, m + n) && [m + n + 1, m + n + n)
            if (y != 0 && y != n) {
                int va = min(a[y], a[y + 1]);
                for (int z = first[m + y]; z; z = nxt[z]) {
                    if (z % 2 == 1 && cap[z] != 0 && w[z] <= m) {
                        int vb = b[w[z]];
                        int va = min(a[y], a[y + 1]);
                        AnyPosOK_bset.erase(vb);
                        LbTOa.push_back({vb, rkL[va], va, va});
                        if (DEBUG) {
                            printf("LbTOa: (b = %d a = %d) va = %d vb = %d\n", w[z], y, va, vb);
                        }
                    }
                }
                va = max(a[y], a[y + 1]);
                for (int z = first[m + n + y]; z; z = nxt[z]) {
                    if (z % 2 == 1 && cap[z] != 0 && w[z] <= m) {
                        int vb = b[w[z]];
                        AnyPosOK_bset.erase(vb);
                        RbTOa.push_back({vb, rkR[va], va, va});
                        if (DEBUG) {
                            printf("RbTOa: (b = %d a = %d) va = %d vb = %d\n", w[z], y, va, vb);
                        }
                    }
                }
                // 查询每个区间实际是匹配的上升区间还是下降区间
                from[y] = 0;
                for (int z = first[m + n + n + y]; z; z = nxt[z]) {
                    if (z % 2 == 1 && cap[z] != 0) {
                        if (w[z] > m && w[z] <= m + n) {
                            from[y] = 1;
                        } else if (w[z] > m + n && w[z] <= m + n + n) {
                            from[y] = 2;
                        }
                    }
                }
            }
            // 这里其实只有 y == 0 或 y == n 时才会被直接从[1, m]产生流量 [TODO——验证猜想]
            for (int z = first[m + n + n + y]; z; z = nxt[z]) {
                if (z % 2 == 1 && cap[z] != 0 && w[z] <= m) {
                    int vb = b[w[z]];
                    AnyPosOK_bset.erase(vb);
                    break;
                }
            }
        }
        // In LbTOa or RbTOa, {tp:vb, id:rk, l:va, r:va}, the same value makes rk seem to be bigger
        // In vaL or vaR, {vL or vR, id}]
        // vaL[i], the i-th smallest val and pos
        // vaR[i], the i-th biggest val and pos
        FMS(pos, 0, n + 2);
        int LpreID = 0;
        sort(LbTOa.begin(), LbTOa.end(), cmpL); // vaL is going down after sorting
        for(auto &it : LbTOa) {
            LpreID = min(it.id, LpreID + 1);
            while(true) {
                int p = vaL[LpreID].second;
                if (from[p] != 1)++LpreID;
                else {
                    pos[p] = it.tp;
                    break;
                }
            }
        }
        int RpreID = 0;
        sort(RbTOa.begin(), RbTOa.end(), cmpR); // vaR is going up after sorting
        for(auto &it : RbTOa) {
            it.id = min(it.id, RpreID + 1);
            RpreID = it.id;
            while(true) {
                int p = vaR[RpreID].second;
                if (from[p] != 2)++RpreID;
                else {
                    pos[p] = it.tp;
                    break;
                }
            }
        }
        if (DEBUG) {
            printf("POS: ");
            for(int i = 1; i < n; ++i)printf("%d ", pos[i]);
            puts("");
        }
        // ans output
        ansVec.clear();
        for (int y = 0; y <= n; ++y) {
            if (y) {
                ansVec.push_back(a[y]);
            }
            // possibility 1: matched already
            if (y != 0 && y != n && pos[y]) {
                ansVec.push_back(pos[y]);
                continue;
            }
            // possibility 2: head or tail
            bool flag = 0;
            if (y == 0 || y == n) {
                for (int z = first[m + n + n + y]; z; z = nxt[z]){
                    if (z % 2 == 1 && cap[z] != 0 && w[z] <= m) {
                        ansVec.push_back(b[w[z]]);
                        flag = 1;
                        break;
                    }
                }
            }
            // possibility 3: any position is the same to some elements
            if(!flag && AnyPosOK_bset.size()) {
                ansVec.push_back(*AnyPosOK_bset.begin());
                AnyPosOK_bset.erase(AnyPosOK_bset.begin());
            }
        }
        SUM = 0;
        for(int i = 0; i < ansVec.size(); ++i) {
            printf("%d ", ansVec[i]);
            if (i)SUM += abs(ansVec[i] - ansVec[i - 1]);
        }puts("");
    }

    // 低效建图法，边数O(nm)
    void NmultM_mapBuild() {
        ID = 1;
        ST = 0;
        ED = m + 1 + n + 1;
        for (int i = 1; i <= m; ++i) {
            int V = b[i];
            ins(ST, i, 1, 0);
            for (int j = 0; j <= n; ++j) {
                int lftV = j == 0 ? V : a[j];
                int rgtV = j == n ? V : a[j + 1];
                int oriV = (j == 0 || j == n) ? 0 : abs(a[j + 1] - a[j]);
                int incV = abs(lftV - V) + abs(rgtV - V) - oriV;
                ins(i, m + 1 + j, 1, incV);
            }
        }
        for (int i = 0; i <= n; ++i) {
            ins(m + 1 + i, ED, 1, 0);
        }
    }

    // 低效建图下的解构造
    void NmultM_output() {
        // ST = 0
        // b[] ∈ [1, m]
        // a[] ∈ [m + 1 + 0, m + 1 + n]
        // ED = n + m + 2
        vectoransVec;
        for (int i = 0; i <= n; ++i) {
            pos[i] = 0;
        }
        for (int x = 1; x <= m; ++x) {
            for (int z = first[x]; z; z = nxt[z]) {
                if (z % 2 == 0 && cap[z] == 0) {
                    pos[w[z] - m - 1] = b[x];
                }
            }
        }
        for (int i = 0; i <= n; ++i) {
            if(i) ansVec.push_back(a[i]);
            if(pos[i])ansVec.push_back(pos[i]);
        }
        for(auto &it : ansVec) {
            printf("%d ", it);
        }puts("");
    }

    // 输出实际的流量网络图的DEBUG过程
    void printMap() {
        for (int x = 0; x <= ED; ++x) {
            for (int z = first[x]; z; z = nxt[z]) {
                if (z % 2 == 0) {
                    int y = w[z];
                    if (cap[z ^ 1] != 0)
                        printf("%d->%d（%d, %d）\n", x, y, cap[z ^ 1], cost[z]);
                }
            }
        }
    }
}mcmf;

//暴力DFS算法
struct My_BF {
    int rev[1 << 20];
    LL MAXV;
    vectorBEST;
    vectoransVec, vec;
    void init() {
        for(int i = 0; i < 20; ++i) {
            rev[1 << i] = i;
        }
    }
    int lowbit(int x) {
        return x & -x;
    }
    void dfs(int mask, int pos, LL sumV, int num) {
        if (num == m && sumV > MAXV) {
            MAXV = sumV;
            ansVec = vec;
        }
        if (sumV > BEST[num - 1]) {
            BEST[num - 1] = sumV;
        }
        if (pos > n) {
            return;
        }
        for (int tmp = mask; tmp; tmp -= lowbit(tmp)) {
            int o = rev[lowbit(tmp)];
            int v = b[o + 1];
            int addV = 0;
            if (pos == 0) {
                addV = abs(v - a[pos + 1]);
            }
            else if (pos == n) {
                addV = abs(v - a[pos]);
            }
            else {
                addV = abs(v - a[pos + 1]) + abs(v - a[pos]);
            }
            vec.push_back(v); if (pos < n)vec.push_back(a[pos + 1]);
            dfs(mask - lowbit(tmp), pos + 1, sumV + addV, num + 1);
            vec.pop_back(); if (pos < n)vec.pop_back();
        }
        int addV = 0;
        if (pos != 0 && pos != n) {
            addV = abs(a[pos] - a[pos + 1]);
        }
        if (pos < n)vec.push_back(a[pos + 1]);
        dfs(mask, pos + 1, sumV + addV, num);
        if (pos < n)vec.pop_back();
    }
    vector solve() {
        init();
        BEST.resize(m);
        for (int i = 0; i <= m; ++i) {
            BEST[i] = -1;
        }
        MAXV = -1;
        dfs((1 << m) - 1, 0, 0, 0);
        return BEST;
    }
    void output() {
        for (int i = 0; i < ansVec.size(); ++i) {
            printf("%d ", ansVec[i]);
        }
        puts("");
    }
}bf;

// 贪心算法——TODO
struct My_Greedy {
    LL solve() {
        return 0;
    }
}greedy;

// 数据生成器
struct My_DataGenerator {
    void rd_dataGenerator() {
        srand(time(0));
        freopen("Blood Pressure Game.in", "w", stdout);
        casenum = 1000; printf("%d\n", casenum + 0);
        int smlCasenum = 990;
        int midDCasenum = 997;
        for (casei = 1; casei <= casenum; ++casei)
        {
            int n = rand() % 100 + 1;
            if (casei > smlCasenum) {
                n = rand() % 600 + 1;
            }
            else if(casei > midDCasenum) {
                n = 600;
            }
            m = rand() % (n + 1) + 1;
            int TOPV = casei <= smlCasenum ? n * 10 : (rand() % 2 ? 10000 : E9);
            printf("%d %d\n", n, m);
            setnoEqualSot;
            for(int i = 1; i <= n; ++i) {
                do
                {
                    a[i] = rand() % TOPV + 1;
                }while(noEqualSot.count(a[i]));
                noEqualSot.insert(a[i]);
                printf("%d ", a[i]);
            }puts("");
            for(int i = 1; i <= m; ++i) {
                do
                {
                    b[i] = rand() % TOPV + 1;
                }while(noEqualSot.count(b[i]));
                noEqualSot.insert(b[i]);
                printf("%d ", b[i]);
            }puts("");
        }
    }
}dataGenerator;

struct Checker {
    string check_it() {
        auto& ansVec = mcmf.ansVec;
        setsot;
        for (int i = 0; i < n + m; ++i) {
            int v = ansVec[i];
            if(sot.count(v)) {
                return "same value element in ansVec[]";
            }
            sot.insert(v);
        }
        // array check
        setbset;
        for (int i = 1; i <= m; ++i) {
            bset.insert(b[i]);
        }
        int nxtPos = 1;
        int bnum = 0;
        for(int i = 0; i < n + m; ++i) {
            if (nxtPos <= n && a[nxtPos] == ansVec[i]) {
                ++nxtPos;
                bnum = 0;
            }
            else {
                if(!bset.count(ansVec[i])) {
                    return "it is a wrong final array %d";
                }
                bset.erase(ansVec[i]);
                if (++bnum > 1) {
                    return "can not insert continuous elements of array b";
                }
            }
        }
        return "AC";
    }
}checker;

void printVec(string str, vectorvec) {
    if (str != "") printf("%s: ", str.c_str());//cout << str << ": ";
    for(auto &it : vec) {
        printf("%lld ", it);
    }puts("");
}
void printVec(string str, vectorvec) {
    if (str != "") printf("%s: ", str.c_str());//cout << str << ": ";
    for(auto &it : vec) {
        printf("%d ", it);
    }puts("");
}

void HumanData()
{
    srand(time(0));
    freopen("Human Data.in", "w", stdout);
    casenum = 8; printf("%d\n", casenum);
    for (casei = 1; casei <= casenum; ++casei) {
        setsot;
        n = 600; m = 601;
        printf("%d %d\n", n, m);
        int basic = 5000 + rand() % 1000;
        int dif = rand() % 3 + 2;
        a[1] = basic; sot.insert(a[1]);
        a[2] = basic + 1; sot.insert(a[2]);
        for(int i = 3; i <= n; ++i){
            if (i & 1)a[i] = a[i - 2] - dif;
            else a[i] = a[i - 2] + dif;
            sot.insert(a[i]);
        }
        for(int i = 1; i <= n; ++i) {
            printf("%d ", a[i]);
        }puts("");
        for(int i = 1; i <= m; ++i) {
            do{
                b[i] = rand() % (basic + dif * n) + 1;
            }while(sot.count(b[i]));
            sot.insert(b[i]);
            printf("%d ", b[i]);
        }puts("");
    }
}

int main() {
    // HumanData(); return 0;
    // dataGenerator.rd_dataGenerator(); return 0;
    freopen("Blood Pressure Game.in", "r", stdin); freopen("Blood Pressure Game.out", "w", stdout);
    // freopen("Human Data.in", "r", stdin);
    scanf("%d", &casenum); for(casei = 1; casei <= casenum; ++casei) {
        printf("Case #%d:\n", casei);
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
        for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
        LL basic = 0;
        for (int i = 2; i <= n; ++i) {
            basic += abs(a[i] - a[i - 1]);
        }

        // solution 1: fastNetworkFlow
        bool NplusM_MCMF = true;
        vector fastMCMFvec;
        if (NplusM_MCMF) {
            mcmf.NplusM_mapBuild();
            fastMCMFvec = mcmf.fastMCMF(basic);
            printVec("", fastMCMFvec); //fastMCMFvec
            mcmf.NplusM_output();
            FMS(mcmf.first, 0, mcmf.ED + 2);
            // ans checker
            string check_str = checker.check_it();
            if(check_str != "AC") {
                puts(check_str.c_str());
                for (int i = 1; i <= n; ++i) {
                    printf("%d ", a[i]);
                }puts("");
                for (int i = 1; i <= m; ++i) {
                    printf("%d ", b[i]);
                }puts("");
                printf("SUM = %lld\n", mcmf.SUM);
                while(true);
            }
            if(DEBUG) {
                mcmf.printMap();
            }
        }

        // solution 2: slowNetworkFlow
        bool NmultM_MCMF = false;
        vector slowMCMFvec;
        if (NmultM_MCMF) {
            mcmf.NmultM_mapBuild();
            slowMCMFvec = mcmf.slowMCMF(basic);
            printVec("", slowMCMFvec); // slowMCMFvec
            mcmf.NmultM_output();
            FMS(mcmf.first, 0, mcmf.ED + 2);
            if (NplusM_MCMF && slowMCMFvec != fastMCMFvec) {
                puts("Error: slowMCMFvec != fastMCMFvec");
                while(true);
            }
        }

        // solution 3: Brute Force (DFS)
        bool bruteForce = false;
        if (bruteForce) {
            vector BFvec = bf.solve();
            printVec("BFvec", BFvec);
            bf.output();
            if (NplusM_MCMF && BFvec != fastMCMFvec) {
                puts("Error: BFvec != fastMCMFvec");
                while(true);
            }
        }

        // solution 4: Greedy
        // LL ans_greedy = greedy.solve();
    }
    return 0;
}
/*
 【Trick && Tsukkomi】

 Input
 1
 4 5
 21 3 48 39
 16 66 9 64 36
 Output
 36 21 66 3 64 48 9 39 16

 Input
 1
 4 4
 10 50 3 6
 1 9 23 5
 Output
 150
 5 10 1 50 3 23 6 9

 【题意】
 把 m 个数任意插入到长度为 n 的数组中的缝隙或两侧，在每个位置最多只能插入一个数的条件下，使得相邻数之差的绝对值的和尽可能大。

 【分析】
 这道题，题目是将 m 个待插入数值，向 n + 1 个区间做插入。而这个插入其实也就是匹配。这种带权匹配问题，我们可以使用网络流（费用流）算法来解决。
 因为我们希望最终的差值之和尽可能大，所以这个"费用"此处是"收益"，我把它称呼为最大收益最大流好啦。

 因为匹配的可能是 n * m ，这个图实际构成了"完全二分图"，边数是m * (n + 1).
 然而，面对1000的数据规模，O(nm) 的边数就已经巨大无比了，最终算法的复杂度将会难以吃得消。
 要怎么办才好呢？我们可以结合这道题的特殊性，优化建图！
 可以看到——除了首尾这两个特殊的插入位置外，其他所有的插入位置都可以用一个二元对[l, r]来表示。
 如果插入的数值 v 比 l 小，其实收益只与 l 有关，是 (l - v) * 2
 如果插入的数值 v 比 r 大，其实收益只与 r 有关，是 (v - r) * 2
 否则，插入的数值在区间内，则该插入操作不会产生任何收益。

 显然，我们发现，对于插入区间，笼统来说，是具有 l 越大优、或 r 越小越优的性质的。
 其实也就是说，如果我们最终做了匹配 v < [l2, r2]，那么不可能我们有一个闲置未匹配区间[l1, r1](l1 > l2)的，这样 v 匹配[l1, r1]一定更优。
 同理，       如果我们最终做了匹配 [l2, r2] > v，那么不可能我们有一个闲置未匹配区间[l1, r1](r1 < r2)的，这样 v 匹配[l1, r1]一定更优
 而对于两个区间，其替换后价值的收益其实是线性的。如 v < [l2, r2]，由[l2, r2]调整为[l1, r1](l1 > l2)的时候，收益是(l1 - l2) * 2

 发现了这些性质后，我们就可以优化建图啦——
 (1) 设置源点编号为0，汇点编号为 m + n * 3 + 1
 (2) 源点连接 m 个被插入点[1, m], 容量统一为1，收益统一为0 <此处m条边>
 (3) 把所有非两侧的可插入区间，抽象为[m + 1, m + n)这 n - 1 个点，
    按照左界从大到小（从优到差）排序，我们考虑每个区间都可能匹配(插入)了比它小的数值(v < l)
    从区间 [l[i + 1], r[i + 1]] 向区间 [l[i], r[i]] 连一条容量极大(>=m即可)，收益为(l[i] - l[i + 1]) * 2的边 <此处n - 2条边>
 (4) 把所有非两侧的可插入区间，抽象为[m + n + 1, m + n + n)这 n - 1 个点，
    按照右界从小到大（从优到差）排序，我们考虑每个区间能可能匹配(插入)了比它大的数值(v > r)
    从区间 [l[i + 1], r[i + 1]] 向区间 [l[i], r[i]] 连一条容量极大(>=m即可)，收益为(r[i + 1] - r[i]) * 2的边 <此处n - 2条边>
 (5) 然而，一个区间最多只能匹配一次，即不可能其既作为较大的区间被插入了值，同时由作为最小的区间被插入了值。
    因此，我们再设置 [m + n + n + 0, m + n + n + n] 这 n + 1 个点，这些点向汇点 ED 连一条容量为1，收益为0的边 <此处n + 1条边>
    同时，对于i ∈ [1, n), m + i 与 m + n + i 同时向 m + n + n + i 连一条容量为1(>=1即可)，收益为0的边 <此处(n - 1) * 2条边>
    于是，我们控制使得每个区间被最多匹配一次，同时一个区间不可能同时作为较大区间和较小区间同时被匹配插入。
 (6) 注意到，可以被插入匹配的位置其实有 n + 1 个，而对于首区间和尾区间，编号实际为 m + n + n + 0 和 m + n + n + n，
    我们直接从 m 个插入点向这 2 个特殊插入位置连一条容量为1(>=1即可)，收益为0的边 <此处m * 2条边>
 (7) 不要忘记了，"向下匹配的左界区间"和"向上匹配的右界区间"，虽然它们都被连成了链，且连入了唯一编号的区间，但却没有流量流入。
    对于 m 个插入值 v ，向比其大的第一个(如果存在) "下匹配的左界区间[l, r]", 连一条容量为1(>=1即可)，收益为(l - v) * 2的边
    同理，             向比其小的第一个(如果存在) "上匹配的右界区间[l, r]", 连一条容量为1(>=1即可)，收益为(v - r) * 2的边
    <此处最多m * 2条边>

 这个图最终形成啦。
 层次包括六层{源点0}、{插入层[1, m]}、{下匹配左界区间层[m + 1, m + n)}、{上匹配右界区间层[m + n + 1, m + n + n)}、{真实区间层[m + n + n + 0, m + n + n + n]}、{汇点m + n * 3 + 1}
 点数总共2 + m + (n - 1) + (n - 1) + (n + 1)共计m + n * 3 + 1个，即点数为4n级别
 同时，边数可以由(1)~(7)求和可得，为10n级别
 因而，算法的复杂度为O(点数为4n边数为10n的费用流复杂度) :p

 【数据】
6

2 3
5 11
10 3 1

4 1
1 2 3 4
5

4 2
1 2 3 4
5 6

4 5
1 2 3 4
5 6 7 8 9

4 4
10 50 3 6
1 9 23 5

4 2
10 50 3 6
9 23

 */

扫地机类清洁产品之直流无刷电机控制悟空胆好小清洁服务机器人单片机人工智能
扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
2020-04-12每天三百字之连接与替代冷眼看潮
不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
东南林氏之九牧林候选父系祖缘树TheYtree
渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
大伟说成语之唉声叹气求索大伟
＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
libyuv之linux编译 jaronho Linux linux 运维服务器
文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
锁之缘尘缘诗词原创作品
是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
2020-12-24 我和我的天使们
阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
18、架构-可观测性之聚合度量大树~~ 架构 java python 后端架构
聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
学习“论语”-第59天春峰轩
12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
2021-11-15 宙火
我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
《我的青葱岁月之缘来是你》第二章迎新晚会思源思缘思怨
“怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
厦门自由行之第一天: 大苏子在广漂
厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
“这才好”麻辣香锅能够增加人身体的免疫能力小补文知
我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
《太虚游》第六十二章。玄牝之威。古楼臭道士
“好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
生命如花坦释空
每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
二婚到底是领证好还是不领证好？孟妃青
伟人讲过，不以结婚为目的的谈恋爱，都是耍流氓！离婚了，再找对象，感情到了一定程度，领证结婚是水到渠成的事，再说我中华泱泱大国，有礼仪之邦的称谓，领证更是体现了尊重男女双方的行为。如果认为二婚就没必要领证了，只能说明，男女之间都暗藏心思，心不往一处走，日子过不好的。即便他们感情再深，都不是合法夫妻，只是名不正言不顺的同居关系。假如不要二人共同的孩子还好，就怕有了孩子，没领证，到时给孩子上户口都成问题
《华杉讲透王阳明传习录》微微微微神
〔5〕希渊问：“圣人可学而至。然伯夷伊尹于孔子，才力终不同。其同谓之圣者安在”？先生曰，“圣人之所以为圣，只是其心纯乎天理，而无人欲之杂。犹精金之所以为精，但以其成色足而无铜铅之杂也。人到纯乎天理方是圣。金到足色方是精。然圣人之才力，亦有大小不同。犹金之分两有轻重。尧舜犹万镒。文王孔子犹九千镒。禹汤武王犹七八千镒。伯夷伊尹犹四五千镒。才力不同，而纯乎天理则同。皆可谓之圣人。犹分两虽不同，而足色则同
“日舍一物”之42——活在当下，并向前看記二十一
这件衣服已经有十五、六年了（突然发现我可真是能囤东西啊）。这原本是一件我非常喜欢的衣服，无论是样子，还是质地。照片拍的比较渣，但其实，白色棉质衣料中，尚织有银色的丝线，在阳光或灯光下，会闪亮，不晃眼，但很漂亮。或许正是因为太喜欢了，所以一直保留着，尽管很多年都没有再穿过了。因为不合适了。首先是随着年龄的增长，尽管体重总量没有太多变化（哦，其实还是涨了）。但是体型还是和十几年前不一样了，最明显的就是
语文主题教学学习笔记之87 东哥杂谈
“语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类） AdyZhang POJO eclipse Hibernate MiddleGenIDE
推荐:MiddlegenIDE插件, 是一个Eclipse 插件. 用它可以直接连接到数据库, 根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件! 今天开始试着使用
.9.png Cb123456 android
“点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
算法的效率天子之骄算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
算法的效率效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。以下是我的学习笔记： 1.求值与霍纳法则，即为秦九韶公式。 2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。
java数据结构何必如此 java 数据结构
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：枚举（Enumeration）位集合（BitSet）向量（Vector）栈（Stack）字典（Dictionary）哈希表（Hashtable）属性（Properties）以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
MybatisHelloWorld 3213213333332132
//测试入口TestMyBatis package com.base.helloworld.test; import java.io.IOException; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibat
Java|urlrewrite|URL重写|多个参数 7454103 java xml Web 工作
个人工作经验！如有不当之处，敬请指点 1.0 web -info 目录下建立 urlrewrite.xml 文件类似如下： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE u
达梦数据库+ibatis darkranger sql mysql ibatis SQL Server
--插入数据方面如果您需要数据库自增... 那么在插入的时候不需要指定自增列. 如果想自己指定ID列的值, 那么要设置 set identity_insert 数据库名.模式名.表名; ----然后插入数据; example: create table zhabei.test( id bigint identity(1,1) primary key, nam
XML 解析四种方式 aijuans android
XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object
spring中配置文件占位符的使用 avords
1.类 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
前端工程化-公共模块的依赖和常用的工作流 bee1314 webpack
题记：一个人的项目，还有工程化的问题嘛？我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？你真的想这样嘛？ var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。
上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？ bijian1013 项目管理沟通 IT职业规划
问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。 Eno-Bea回答，注重感受，不一定是别人的虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
TortoiseSVN，过滤文件征客丶 SVN
环境： TortoiseSVN 1.8 配置：在文件夹空白处右键选择 TortoiseSVN -> Settings 在 Global ignote pattern 中添加要过滤的文件：多类型用英文空格分开 *name ：过滤所有名称为 name 的文件或文件夹 *.name ：过滤所有后缀为 name 的文件或文件夹 --------
【Flume二】HDFS sink细说 bit1129 Flume
1. Flume配置 a1.sources=r1 a1.channels=c1 a1.sinks=k1 ###Flume负责启动44444端口 a1.sources.r1.type=avro a1.sources.r1.bind=0.0.0.0 a1.sources.r1.port=44444 a1.sources.r1.chan
The Eight Myths of Erlang Performance bookjovi erlang
erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html Myth: Funs are sl
java多线程网络传输文件(非同步)-2008-08-17 ljy325 java 多线程 socket
利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 客户端: 修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
读《研磨设计模式》-代码笔记-模板方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;
配置心得 chenyu19891124 配置
时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。做了一年的配置管理给自总结下： 1.改变从一个以前对配置毫无
对“带条件选择的并行汇聚路由问题”的再思考 comsci 算法工作软件测试嵌入式领域模型
2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
Oracle 10g 的clusterware 32位下载地址 daizj oracle
Oracle 10g 的clusterware 32位下载地址 http://pan.baidu.com/share/link?shareid=531580&uk=421021908 http://pan.baidu.com/share/link?shareid=137223&uk=321552738 http://pan.baidu.com/share/l
非常好的介绍：Linux定时执行工具cron dongwei_6688 linux
Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
Yii assets目录生成及修改 dcj3sjt126com yii
assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 assets设置对应的方法位置 \framework\web\CAssetManager.php assets配置方法在m
mac工作软件推荐 dcj3sjt126com mac
mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。我为什么要要iterm2 切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： * 兼容性好，远程服务器 vi 什么的低版本能很好兼
Memcached(三)、封装Memcached和Ehcache frank1234 memcached ehcache spring ioc
本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 cache.xml <?xml version="1.0" encoding="UTF-8"?>
Remove Duplicates from Sorted List II hcx2013 remove
Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5,
Spring4新特性——注解、脚本、任务、MVC等其他特性改进 jinnianshilongnian spring4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
MySQL安装文档 liyong0802 mysql
工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。 Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
使用VS2010构建HotSpot工程 p2p2500 HotSpot OpenJDK VS2010
1. 下载OpenJDK7的源码： http://download.java.net/openjdk/jdk7 http://download.java.net/openjdk/ 2. 环境配置 ▶
Oracle实用功能之分组后列合并 seandeng888 oracle 分组实用功能合并
1 实例解析由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下：表test 数据如下： ID,SUBJECTCODE,DIMCODE,VALUE 1&nbs
Java定时任务注解方式实现 tuoni java spring jvm xml jni
Spring 注解的定时任务，有如下两种方式：第一种： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http
11大Java开源中文分词器的使用方法和分词效果对比 yangshangchuan word分词器 ansj分词器 Stanford分词器 FudanNLP分词器 HanLP分词器
本文的目标有两个： 1、学会使用11大Java开源中文分词器 2、对比分析11大Java开源中文分词器的分词效果本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比

2019 ICPC 上海 M Blood Pressure Game [血压游戏] 出题人原封不动标程

你可能感兴趣的:(好题,贪心,图论-网络流之费用流)