象棋上有个新字中国象棋是啥

Posted 2023-04-26

《新中国象棋》是一款android平台的应用。1
基本内容
一．游戏简介

新中国象棋是中国一种流传十分广泛的游戏。下棋双方根据自己对棋局形式的理解和对棋艺规律的掌握，调动车马，组织兵力，协调作战在棋盘－－这块特定的战场上进行着象征性的军事战斗。

二、规则介绍

以下一些名词是中国象棋的一些棋盘与棋子的说明：

1、棋盘

棋子活动的场所，叫做 " 棋盘 " ，在长方形的平面上，绘有九条平行的竖线和十条平行的横线相交组成，共九十个交叉点，棋子就摆在这些交叉点上。中间第五、第六两横线之间未画竖线的空白地带，称为 " 河界 " ，整个棋盘就以 " 河界 " 分为相等的两部分；两方将帅坐镇、画有 " 米 " 字方格的地方，叫做 " 九宫 " 。

2、棋子

象棋的棋子共三十二个，分为红黑两组，各十六个，由对弈双方各执一组，每组兵种是一样的，各分为七种：

　　红方：帅 (1) 、仕 (2) 、相 (2) 、车 (2) 、马 (2) 、炮 (2) 、兵 (5)

　　黑方：将 (1) 、士 (2) 、象 (2) 、车 (2) 、马 (2) 、炮 (2) 、卒 (5)

其中帅与将、仕与士、相与象、兵与卒的作用完全相同，仅仅是为了区分红棋和黑棋。

3、各棋子的走法说明

将或帅

移动范围：它只能在王宫内移动。

移动规则：它每一步只可以水平或垂直移动一点。

士

移动范围：它只能在王宫内移动。

移动规则：它每一步只可以沿对角线方向移动一点。

象

移动范围：河界的一侧。

移动规则：它每一步只可以沿对角线方向移动两点，另外，在移动的过程中不能够穿越障碍。

马

移动范围：任何位置

移动规则：每一步只可以水平或垂直移动一点，再按对角线方面向左或者右移动。另外，在移动的过程中不能够穿越障碍。

车

移动范围：任何位置

移动规则：可以水平或垂直方向移动任意个无阻碍的点。

炮

移动范围：任何位置

移动规则：移动起来和车很相似，但它必须跳过一个棋子来吃掉对方的一个棋子。

兵

移动范围：任何位置

移动规则：每步只能向前移动一点。过河以后，它便增加了向左右移动的能力，兵不允许向后移动。

三．时间设置说明

QQ 中国象棋的时间设置包括"局时"，"步时"与"读秒"，每个玩家分别计算自己的"局时"，"步时"与"读秒"。玩家在下棋过程中，首先进行"局时"与"步时"的计算。在局时超时之前，每一步走棋必须在"步时"限定之内走完一步棋子，在走下一步棋的时候，"步时"重新进行计算。当"局时"超时以后，"局时"停止计算，玩家必须在"读秒"规定的时间之内走完一步棋。"步时"与"读秒"的超时都会引起棋局结束，超时者判输。

例如，假设某一局棋局中"局时"、"步时"、"读秒"的设置分别为 30 分钟、 5 分钟、 3 分钟。玩家在下棋过程中首先会进行局时的计算，在局时 30 分钟结束之前，玩家每一步的走棋都必须在 5 分钟之内完成。当局时 30 分钟计算结束后，玩家必须在 3 分钟之内完成每一步走棋。

四．关于胜、负、和

对局中，出现下列情况之一，本方算输，对方赢：

1 、己方的帅（将）被对方棋子吃掉；

2 、己方发出认输请求；

3 、己方走棋超出步时限制；

4 、己方超时

5 、己方逃跑

注意：如果只有一方走了一步棋，另外一方还没有进行走棋情况下出现了"认输""超时""逃跑"的情况，那么分数将不会进行计算。

五．积分与级别

每一位玩家第一次进入 QQ 中国象棋时，都会获得 1300 分的初始积分。

九级棋手 =0 八级棋手 =1100 七级棋手 =1200 六级棋手 =1300

五级棋手 =1400 四级棋手 =1500 三级棋手 =1600 二级棋手 =1700

一级棋手 =1800 三级大师 =2000 二级大师 =2200 一级大师 =2400

特级大师 =2600 参考技术A 中国象棋：

在中国有着悠久的历史，属于二人对抗性游戏的一种，由于用具简单，趣味性强，成为流行极为广泛的棋艺活动，中国象棋是我国正式开展的78个体育运动项目之一。

象棋的起源：

1、虞舜为弟制棋说：

舜的同父异母弟弟叫象，兄弟二人不和，象为取代舜，曾多次设计谋杀舜，舜后来幽禁了象，为避免弟弟寂寞，制作了棋戏，因是给象下的，于是得名象棋；

2、源自楚辞说：

楚辞·招魂里有琨蔽象棋,有六簙兮，但很多人都认为这里的象棋，指的是六簙戏所用的以象牙做的棋子，不是象棋；

3、源自易经说：

有人认为，象数象戏象棋，一脉相承，都有推演休咎的特点，象棋之象，就是象数之象。 参考技术B 中国象棋和新中国象棋的区别：

1、等级不一样

在中国象棋里是由草民、秀才、县今、将军等级别。而新中国象棋是分九级棋士，八到一级棋士，其次是三级大师二级大师、一级大师、最后是特级大师。

2、时间的设计不一样

中国象棋里可以设计一走一步一秒种，而新中国象棋却最近只能设三十秒。

3、规格不同

新中国象棋的棋子比中国象棋大许多。 参考技术C 规则与中国象棋不一样。
其区别：1、等级不一样在中国象棋里是由草民、秀才、县今、将军等级别。而新中国象棋是分九级棋士，八到一级棋士，其次是三级大师二级大师、一级大师、最后是特级大师。2、时间的设计不一样中国象棋里可以设计一走一步一秒种，而新中国象棋却最近只能设三十秒。3、规格不同新中国象棋的棋子比中国象棋大许多。 参考技术D 1、等级不一样
在中国象棋里是由草民、秀才、县今、将军等级别。而新中国象棋是分九级棋士，八到一级棋士，其次是三级大师二级大师、一级大师、最后是特级大师。
2、时间的设计不一样
中国象棋里可以设计一走一步一秒种，而新中国象棋却最近只能设三十秒。
3、规格不同
新中国象棋的棋子比中国象棋大许多。

题解 Luogu P2499: [SDOI2012]象棋

关于这道题, 我们可以发现移动顺序不会改变答案, 具体来说, 我们有以下引理成立:

• 对于一个移动过程中的任意一个移动, 若其到达的位置上有一个棋子, 则该方案要么不能将所有棋子移动到最终位置, 要么可以通过改变顺序使这一次移动合法

证明:

考虑到达位置上的那个棋子, 如果它没有到达最终位置, 则我们考虑将该棋子移至下一步, 如果下一步还有没有到达最终位置的棋子, 则也移动它

否则直接调换这两个棋子的移动顺序即可

好的我们去除了题目中的要求: 「移动过程中不能出现多颗棋子同时在某一格的情况」, 接下来考虑题目被我们转化成了什么样子:

给定(k)个起始点和它们到达(k)个终点的步数, 求一种移动方案, 使得这种移动方案能将所有起始点移动到终点(保证有方案), 其次使得所花费的步数最少.

于是我们把这道题目转化为了一个费用流问题, 具体的, 我们建立超级源点(S), 超级汇点(T), 接下来连接三类边

1. (S ightarrow)所有起始点, 这类边容量为1, 费用为0

2. 每一个起始点( ightarrow)每一个它能够到达的终点, 这类边容量为1, 费用为所消耗的步数

3. 所有终点( ightarrow T), 这类边容量为1, 费用为0

在新图上跑费用流即可AC

要是这道题有这么简单就好了

如果你使用了一般的EK+SPFA, 你会像我这样:

接下来我们考虑改进算法, ouuan在这篇帖子中说道:

常见费用流算法(把 Dinic 的 BFS 改成求最短路)复杂度上界是 (O(nmf)),其中 (f) 是最大流。

于是我们点进了下面的链接学习了那种方法并且AC本题

我不会那种方法>_< 于是使用了Dijkstra跑最短路, 事实上一般的Dijkstra是不能跑的, 但是我在费用流的题解中找到了这种神仙做法

具体来说, 我们定义势函数(h(i))使得(e'(u,v)=e(u,v)+h(u)-h(v)), 最后对最短路的影响可以强行考虑掉, 且(e'(u,v))恒非负, 就可Dijkstra了

接下来我们发现(h(i)=mindis(u))是成立的, 但那样的话你还要跑SPFA求最短路

因此我们转而考虑(h(i)=mindis_{round-1}(u)), 其中(mindis_{round-1}(u))指上一轮(S ightarrow u)的最短路(不存在为0), 我们发现这也是成立的, 具体来说, 我们考虑每条边(e(u,v)).

• 若(e(u,v))在上一次增广时存在, 那么显然满足性质
• 否则(e(u,v))在最短路上, 也可证明(e'(u,v) geq 0)

于是我们的势算法成立, 用Dijkstra替换SPFA即可在luogu上AC本题

#pragma GCC diagnostic error "-std=c++11"
#pragma GCC target("avx")
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
using namespace std;
namespace mcmf {
    const int N=1002; const int M=500*502*2+1; const int inf=0x3f3f3f3f;
    int tot = 1, head[N], Next[M * 2], ver[M * 2], edge[M * 2], cost[M * 2];
    int dis[N], h[N], lst[N], pre[N], C, n;
    #define pi pair<int,int>
    inline void _add(int u, int v, int c, int w) {
        Next[++tot] = head[u], head[u] = tot, ver[tot] = v, edge[tot] = c, cost[tot] = w;
    }
    inline void add(int u, int v, int c, int w) {
        _add(u, v, c, w), _add(v, u, 0, -w);
    }
    void Dijkstra(int s) {
        priority_queue<pi, vector<pi>, greater<pi> > q;
        for(; !q.empty(); q.pop());
        fill(dis, dis + 1 + n, -1);
        dis[s] = 0, q.push(pi(0, s));
        while(!q.empty()) {
            pi now = q.top(); q.pop();
            int u = now.second;
            if(dis[u] < now.first) continue;
            for(int i = head[u]; i; i = Next[i]) {
                static int v; v = ver[i];
                if(!edge[i]) continue;
                if(dis[v] < 0 || dis[v] > dis[u] + cost[i] + h[u] - h[v]) {
                    dis[v] = dis[u] + cost[i] + h[u] - h[v];
                    pre[v] = u, lst[v] = i;
                    q.push(pi(dis[v], v));
                }
            }
        }
    }
    int solve(int s, int t) {
        memset(h,0,sizeof(h)); int d=inf;
        while(1){
            Dijkstra(s); if(dis[t] < 0) break;
            for(register int i = 1; i <= n; ++i) h[i] += (dis[i] != -1) ? dis[i] : 0; d=inf;
            for(int u = t; u != s; u = pre[u]) edge[lst[u]]<d && (d=edge[lst[u]]); C += h[t] * d;
            for(int u = t; u != s; u = pre[u]) edge[lst[u]] -= d, edge[lst[u] ^ 1] += d;
        } 
        return C;
    }
}
const int _=501,__=101;
int n,m,k,a,b;
int un[__][__],dis[__][__];
struct pos{
    int x,y;
}st[_], ed[_];
queue<pos> Q;
int dx[8]={1,1,-1,-1,1,1,-1,-1}, dy[8]={1,-1,1,-1,1,-1,1,-1};
#define in(a) (a.x>=1 && a.x<=n && a.y>=0 && a.y<=m && !un[a.x][a.y])
void getdis(int s){
    Q.push(st[s]); dis[st[s].x][st[s].y]=0; pos x; int d;
    while(!Q.empty()){
        x=Q.front(); d=dis[x.x][x.y]; Q.pop();
        for(int i=0;i<8;++i){
            x.x+=dx[i]; x.y+=dy[i];
            (dis[x.x][x.y]==-1) && in(x) && (Q.push(x),dis[x.x][x.y]=d+1);
            x.x-=dx[i]; x.y-=dy[i];
        }
    }
}
char get(){char c=getchar(); while(c!='*' && c!='.') c=getchar(); return c;}
int main(){
    scanf("%d%d%d%d%d",&n,&m,&k,&a,&b); 
    for(register int i=1;i<=n;++i) for(int j=1;j<=m;++j) {
        char ch=get(); un[i][j]=(ch=='*');
    }
    for(register int i=0;i<4;++i) dx[i]*=a,dy[i]*=b;
    for(register int i=4;i<8;++i) dx[i]*=b,dy[i]*=a;
    for(register int i=1;i<=k;++i) scanf("%d%d",&st[i].x,&st[i].y);
    for(register int i=1;i<=k;++i) scanf("%d%d",&ed[i].x,&ed[i].y);
    for(register int i=1;i<=k;++i) {
        memset(dis,-1,sizeof(dis)); getdis(i);
        for(int j=1;j<=k;++j) if(dis[ed[j].x][ed[j].y]!=-1) mcmf::add(i+1,j+k+1,1,dis[ed[j].x][ed[j].y]);
    }
    for(int i=1;i<=k;++i) mcmf::add(1,i+1,1,0),mcmf::add(i+k+1,2*k+2,1,0);
    mcmf::n=2*k+2; printf("%d
",mcmf::solve(1,2*k+2));
}