Code – 第260页 – 柳婼の blog

1049. 数列的片段和(20)-PAT乙级真题

给定一个正数数列，我们可以从中截取任意的连续的几个数，称为片段。例如，给定数列{0.1, 0.2, 0.3, 0.4}，我们有(0.1) (0.1, 0.2) (0.1, 0.2, 0.3) (0.1, 0.2, 0.3, 0.4) (0.2) (0.2, 0.3) (0.2, 0.3, 0.4) (0.3) (0.3, 0.4) (0.4) 这10个片段。
给定正整数数列，求出全部片段包含的所有的数之和。如本例中10个片段总和是0.1 + 0.3 + 0.6 + 1.0 + 0.2 + 0.5 + 0.9 + 0.3 + 0.7 + 0.4 = 5.0。
输入格式：
输入第一行给出一个不超过105的正整数N，表示数列中数的个数，第二行给出N个不超过1.0的正数，是数列中的数，其间以空格分隔。
输出格式：
在一行中输出该序列所有片段包含的数之和，精确到小数点后2位。
输入样例：
4
0.1 0.2 0.3 0.4
输出样例：
5.00

分析：将数列中的每个数字读取到temp中，假设我们选取的片段中包括temp，且这个片段的首尾指针分别为p和q，那么对于p，有i种选择，即12…i，对于q，有n-i+1种选择，即i, i+1, … n，所以p和q组合形成的首尾片段有i * (n-i+1)种，因为每个里面都会出现temp，所以temp引起的总和为temp * i * (n – i + 1)；遍历完所有数字，将每个temp引起的总和都累加到sum中，最后输出sum的值～

【Update 2020-6-18】PS：题目更新了测试样例，导致之前的代码测试点2（第3个测试点）无法通过，研究到凌晨四点找错误原因…后来找到了给PAT这道题提反馈改测试用例的这位同学写的关于这道题的博客：https://blog.zhengrh.com/post/about-double/，感谢他让我找到了错误的原因，大概意思是：N比较大时，double类型的值多次累加导致的精度误差，因为输入为十进制小数，存储到double中时，计算机内部使用二进制表示，且计算机的字长有限，有的十进制浮点数使用二进制无法精确表示只能无限接近，在字长的限制下不可避免会产生舍入误差，这些细微的误差在N较大时多次累加会产生较大误差，所以建议不要使用double类型进行多次累加的精确计算，而是转为能够精确存储的整型。尝试把输入的double类型的值扩大1000倍后转为long long整型累加，同时使用long long类型保存sum的值，输出时除以1000.0转为浮点型再输出（相当于把小数点向后移动3位后再计算，避免double类型的小数部分存储不精确，多次累加后对结果产生影响）
但我觉得乘以1000也未必严谨，可能测试样例最小只有小数点后三位，如果测试样例变成小数点后四位、五位、六位，乘以1000相当于直接在小数点后三位处截断，而原本第四五六位经过多次累加进位后依然可能会引起精度问题，但如果乘以10000就会超出long long的值，我认为最精确的应该是截取到所有小数中最大的位数的那一位。。可能我的想法有疏漏，经过测试，测试样例确实没有超过小数点后三位，虽然修改为乘以1000后代码已经AC，但如果对测试样例稍加修改，可能又会导致不AC了…所以这道题先打个问号吧，我猜可能将来题目样例还会被修改…

#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    long long sum = 0;
    double temp;
    for (int i = 1; i <= n; i++) { 
        cin >> temp;
        sum += (long long)(temp * 1000) * i * (n - i + 1);
    }
    printf("%.2f", sum / 1000.0);
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

cin >> n;

long long sum = 0;

double temp;

for (int i = 1; i <= n; i++) {

cin >> temp;

sum += (long long)(temp * 1000) * i * (n - i + 1);

}

printf("%.2f", sum / 1000.0);

return 0;

}

打印十字图-蓝桥杯历届试题

问题描述
小明为某机构设计了一个十字型的徽标（并非红十字会啊），如下所示：

对方同时也需要在电脑dos窗口中以字符的形式输出该标志，并能任意控制层数。

输入格式
一个正整数 n (n<30) 表示要求打印图形的层数。

输出格式
对应包围层数的该标志。

样例输入1
1

样例输出1

样例输入2
3

样例输出2

提示
请仔细观察样例，尤其要注意句点的数量和输出位置。

#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    int row = 9 + 4 * (n - 1);
    
    //init
    char a[150][150];
    for(int i = 1; i <= row; i++) {
        for (int j = 1; j <= row; j++) {
            a[i][j] = '.';
        }
    }
    int mid = row / 2 + 1;
    //中间十字架
    for (int i = mid - 2; i <= mid + 2; i++) {
        a[i][mid] = '$';
        a[mid][i] = '$';
    }
    
    //边框十字架
    int tn = n;
    while (tn != 0) {
        int trow = 9 + 4 * (tn - 1);
        // 第一行和最后一行，第一列和最后一列
        for (int i = mid - 2 * tn; i <= mid + 2 * tn; i++) {
            a[mid - 2 * (tn + 1)][i] = '$';
            a[mid + 2 * (tn + 1)][i] = '$';
            a[i][mid - 2 * (tn + 1)] = '$';
            a[i][mid + 2 * (tn + 1)] = '$';
        }
        
        //第二行和倒数第二行，第二列和倒数第二列
        a[mid - 2 * tn - 1][mid - 2 * tn] = '$';
        a[mid - 2 * tn - 1][mid + 2 * tn] = '$';
        a[mid - 2 * tn][mid - 2 * tn - 1] = '$';
        a[mid + 2 * tn][mid - 2 * tn - 1] = '$';
        
        a[mid + 2 * tn + 1][mid - 2 * tn] = '$';
        a[mid + 2 * tn + 1][mid + 2 * tn] = '$';
        a[mid - 2 * tn][mid + 2 * tn + 1] = '$';
        a[mid + 2 * tn][mid + 2 * tn + 1] = '$';
        
        //四个拐弯的角
        a[mid - 2 * tn][mid - 2 * tn] = '$';
        a[mid - 2 * tn][mid + 2 * tn] = '$';
        a[mid + 2 * tn][mid - 2 * tn] = '$';
        a[mid + 2 * tn][mid + 2 * tn] = '$';
        
        //上一层
        tn--;
    }
    
    
    //输出
    for (int i = 1; i <= row; i++) {
        for (int j = 1; j <= row; j++) {
            cout << a[i][j];
        }
        cout << endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int n;

cin >> n;

int row = 9 + 4 * (n - 1);

//init

char a[150][150];

for(int i = 1; i <= row; i++) {

for (int j = 1; j <= row; j++) {

a[i][j] = '.';

}

int mid = row / 2 + 1;

//中间十字架

for (int i = mid - 2; i <= mid + 2; i++) {

a[i][mid] = '$';

a[mid][i] = '$';

}

//边框十字架

int tn = n;

while (tn != 0) {

int trow = 9 + 4 * (tn - 1);

// 第一行和最后一行，第一列和最后一列

for (int i = mid - 2 * tn; i <= mid + 2 * tn; i++) {

a[mid - 2 * (tn + 1)][i] = '$';

a[mid + 2 * (tn + 1)][i] = '$';

a[i][mid - 2 * (tn + 1)] = '$';

a[i][mid + 2 * (tn + 1)] = '$';

}

//第二行和倒数第二行，第二列和倒数第二列

a[mid - 2 * tn - 1][mid - 2 * tn] = '$';

a[mid - 2 * tn - 1][mid + 2 * tn] = '$';

a[mid - 2 * tn][mid - 2 * tn - 1] = '$';

a[mid + 2 * tn][mid - 2 * tn - 1] = '$';

a[mid + 2 * tn + 1][mid - 2 * tn] = '$';

a[mid + 2 * tn + 1][mid + 2 * tn] = '$';

a[mid - 2 * tn][mid + 2 * tn + 1] = '$';

a[mid + 2 * tn][mid + 2 * tn + 1] = '$';

//四个拐弯的角

a[mid - 2 * tn][mid - 2 * tn] = '$';

a[mid - 2 * tn][mid + 2 * tn] = '$';

a[mid + 2 * tn][mid - 2 * tn] = '$';

a[mid + 2 * tn][mid + 2 * tn] = '$';

//上一层

tn--;

}

//输出

for (int i = 1; i <= row; i++) {

for (int j = 1; j <= row; j++) {

cout << a[i][j];

}

cout << endl;

}

return 0;

}

P1001 蓝桥杯算法提高-用字符串处理大数乘法

算法提高 P1001 
时间限制：1.0s 内存限制：256.0MB 
　　当两个比较大的整数相乘时，可能会出现数据溢出的情形。为避免溢出，可以采用字符串的方法来实现两个大数之间的乘法。
具体来说，首先以字符串的形式输入两个整数，每个整数的长度不会超过8位，然后把它们相乘的结果存储在另一个字符串当中（长度不会超过16位），
最后把这个字符串打印出来。例如，假设用户输入为：62773417和12345678，则输出结果为：774980393241726.
输入：
　　62773417 12345678
输出：
　　774980393241726

算法提高 P1001

时间限制：1.0s 内存限制：256.0MB

　　当两个比较大的整数相乘时，可能会出现数据溢出的情形。为避免溢出，可以采用字符串的方法来实现两个大数之间的乘法。

具体来说，首先以字符串的形式输入两个整数，每个整数的长度不会超过8位，然后把它们相乘的结果存储在另一个字符串当中（长度不会超过16位），

最后把这个字符串打印出来。例如，假设用户输入为：62773417和12345678，则输出结果为：774980393241726.

输入：

　　62773417 12345678

输出：

　　774980393241726

继续阅读P1001 蓝桥杯算法提高-用字符串处理大数乘法

学霸的迷宫-蓝桥杯算法提高-广搜 bfs 经典问题

问题描述
　　学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。
输入格式
　　第一行两个整数n， m，为迷宫的长宽。
　　接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。
输出格式
　　第一行一个数为需要的最少步数K。
　　第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。
<img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-more="more" data-wp-more-text="" class="wp-more-tag mce-wp-more" alt="" title="阅读更多…" data-mce-resize="false" data-mce-placeholder="1">


样例输入
Input Sample 1:
3 3
001
100
110

Input Sample 2:
3 3
000
000
000
样例输出
Output Sample 1:
4
RDRD

Output Sample 2:
4
DDRR
数据规模和约定
　　有20%的数据满足：1<=n,m<=10
　　有50%的数据满足：1<=n,m<=50
　　有100%的数据满足：1<=n,m<=500。

问题描述

　　学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。

输入格式

　　第一行两个整数n， m，为迷宫的长宽。

　　接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。

输出格式

　　第一行一个数为需要的最少步数K。

　　第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。

样例输入

Input Sample 1:

3 3

001

100

110

Input Sample 2:

3 3

000

样例输出

Output Sample 1:

RDRD

Output Sample 2:

DDRR

数据规模和约定

　　有20%的数据满足：1<=n,m<=10

　　有50%的数据满足：1<=n,m<=50

　　有100%的数据满足：1<=n,m<=500。

用广度优先搜索解决。bfs。100分。

#include <iostream>
using namespace std;
struct note {
    int x;
    int y;
    int f;
    int s;
    char dir;
};

int main() {
    char a[501][501];
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> a[i][j];
        }
        getchar();
    }
    int head = 1;
    int tail = 1;
    int book[501][501] = {0};
    book[1][1] = 1;
    
    int next[4][2] = {
        {1, 0},
        {0, -1},
        {0, 1},
        {-1, 0}
    };
    int tx = 1;
    int ty = 1;
    
    struct note que[250001];
    que[tail].x = 1;
    que[tail].y = 1;
    que[tail].f = 0;
    que[tail].s = 0;
    tail++;
    int flag = 0;
    while (head < tail) {
        for (int k = 0; k <= 3; k++) {
            tx = que[head].x + next[k][0];
            ty = que[head].y + next[k][1];
            
            if (tx < 1 || tx > n || ty < 1 || ty > m)
                continue;
            if (a[tx][ty] == '0' && book[tx][ty] == 0) {
                book[tx][ty] = 1;
                que[tail].x = tx;
                que[tail].y = ty;
                que[tail].f = head;
                que[tail].s = que[head].s + 1;
                if (k == 0) que[tail].dir = 'D';
                else if (k == 1) que[tail].dir = 'L';
                else if (k == 2) que[tail].dir = 'R';
                else if (k == 3) que[tail].dir = 'U';
                tail++;
            }
            if (tx == n && ty == m) {
                flag = 1;
                break;
            }
        }
        if (flag == 1) {
            break;
        }
        head++;
    }
    cout << que[tail - 1].s << endl;
    char t[250001];
    int temp = tail - 1;
    for (int i = que[tail - 1].s; i >= 1; i--) {
        t[i] = que[temp].dir;
        temp = que[temp].f;
    }
    for (int i = 1; i <= que[tail - 1].s; i++) {
        cout << t[i];
    }
    return 0;
}
[/cpp]

ps:

如果用深度优先搜索dfs，会超时。30分。
[cpp]
#include <iostream>
using namespace std;
char a[501][501];
int book[501][501];
int n, m;
int min1 = 999999;
char s[250001];
char t[250001];
void dfs(int x, int y, int step) {
    int next[4][2] = {
        {1, 0},
        {-1, 0},
        {0, 1},
        {0, -1}
    };
    int tx, ty;
    if (x == n && y == m) {
        if (step < min1) {
            min1 = step;
            for (int i = 1; i <= min1; i++)
                s[i] = t[i];
        }
        return;
    }
    
    for (int k = 0; k <= 3; k++) {
        tx = x + next[k][0];
        ty = y + next[k][1];
        
        if (tx < 1 || ty < 1 || tx > n || ty > m)
            continue;
        if (a[tx][ty] == '0' && book[tx][ty] == 0) {
            book[tx][ty] = 1;
            if (k == 0) t[step] = 'D';
            if (k == 1) t[step] = 'L';
            if (k == 2) t[step] = 'R';
            if (k == 3) t[step] = 'U';
            dfs(tx, ty, step + 1);
            book[tx][ty] = 0;
        }
    }
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> a[i][j];
        }
        getchar();
    }
    book[1][1] = 1;
    dfs(1, 1, 1);
    cout << min1 - 1 << endl;
    for (int i = 1; i < min1; i++) {
        cout << s[i];
    }
    
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

#include <iostream>

using namespace std;

struct note {

int x;

int y;

int f;

int s;

char dir;

};

int main() {

char a[501][501];

int n, m;

cin >> n >> m;

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= m; j++) {

cin >> a[i][j];

}

getchar();

}

int head = 1;

int tail = 1;

int book[501][501] = {0};

book[1][1] = 1;

int next[4][2] = {

{1, 0},

{0, -1},

{0, 1},

{-1, 0}

};

int tx = 1;

int ty = 1;

struct note que[250001];

que[tail].x = 1;

que[tail].y = 1;

que[tail].f = 0;

que[tail].s = 0;

tail++;

int flag = 0;

while (head < tail) {

for (int k = 0; k <= 3; k++) {

tx = que[head].x + next[k][0];

ty = que[head].y + next[k][1];

if (tx < 1 || tx > n || ty < 1 || ty > m)

continue;

if (a[tx][ty] == '0' && book[tx][ty] == 0) {

book[tx][ty] = 1;

que[tail].x = tx;

que[tail].y = ty;

que[tail].f = head;

que[tail].s = que[head].s + 1;

if (k == 0) que[tail].dir = 'D';

else if (k == 1) que[tail].dir = 'L';

else if (k == 2) que[tail].dir = 'R';

else if (k == 3) que[tail].dir = 'U';

tail++;

}

if (tx == n && ty == m) {

flag = 1;

break;

}

if (flag == 1) {

break;

}

head++;

}

cout << que[tail - 1].s << endl;

char t[250001];

int temp = tail - 1;

for (int i = que[tail - 1].s; i >= 1; i--) {

t[i] = que[temp].dir;

temp = que[temp].f;

}

for (int i = 1; i <= que[tail - 1].s; i++) {

cout << t[i];

}

return 0;

}

[/cpp]

ps:

如果用深度优先搜索dfs，会超时。30分。

[cpp]

#include <iostream>

using namespace std;

char a[501][501];

int book[501][501];

int n, m;

int min1 = 999999;

char s[250001];

char t[250001];

void dfs(int x, int y, int step) {

int next[4][2] = {

{1, 0},

{-1, 0},

{0, 1},

{0, -1}

};

int tx, ty;

if (x == n && y == m) {

if (step < min1) {

min1 = step;

for (int i = 1; i <= min1; i++)

s[i] = t[i];

}

return;

}

for (int k = 0; k <= 3; k++) {

tx = x + next[k][0];

ty = y + next[k][1];

if (tx < 1 || ty < 1 || tx > n || ty > m)

continue;

if (a[tx][ty] == '0' && book[tx][ty] == 0) {

book[tx][ty] = 1;

if (k == 0) t[step] = 'D';

if (k == 1) t[step] = 'L';

if (k == 2) t[step] = 'R';

if (k == 3) t[step] = 'U';

dfs(tx, ty, step + 1);

book[tx][ty] = 0;

}

int main() {

cin >> n >> m;

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= m; j++) {

cin >> a[i][j];

}

getchar();

}

book[1][1] = 1;

dfs(1, 1, 1);

cout << min1 - 1 << endl;

for (int i = 1; i < min1; i++) {

cout << s[i];

}

return 0;

}

排列数（输出0~9的全排列）-蓝桥杯算法提高

问题描述

　　0、1、2三个数字的全排列有六种，按照字母序排列如下：
012、021、102、120、201、210
输入一个数n
求0~9十个数的全排列中的第n个（第1个为0123456789）。

输入格式

　　一行，包含一个整数n

输出格式

　　一行，包含一组10个数字的全排列

样例输入

样例输出

0123456789

数据规模和约定

　　0 < n <= 10!
分析：啊我才发现有一个超好用的库函数……完全不用自己实现全排列。。竟然自己还那么笨的用下面的深度优先搜索的办法……next_permutation函数。。在algorithm里面，代码如下：

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    string s = "0123456789";
    int n;
    cin >> n;
    int cnt = 1;
    do {
        if(cnt == n) {
            cout << s;
            break;
        }
        cnt++;
    }while(next_permutation(s.begin(), s.end()));
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

int main() {

string s = "0123456789";

int n;

cin >> n;

int cnt = 1;

do {

if(cnt == n) {

cout << s;

break;

}

cnt++;

}while(next_permutation(s.begin(), s.end()));

return 0;

}

下面是那个笨方法。。。
假设有10个位置，需要在10个位置上依次放置0~9这十个数字。
1.先走到第一个位置，此时放置一个当前可以放置的数字当中最小的那个数字。
2.在走到第二个位置，放置一个当前可以放置的数字当中最小的那个数字。
…
3.到第10个位置时候，所有的数字已经放置完毕，属于第一个全排列。
4.收回第10个位置上的数字，此时还是只可以放置9，那么再到第9个位置面前，收回位置上的数字。
5.在第9个位置处，我们此时可以放置的数字有9，那么第10个位置放8.属于第二个全排列。
6.收回第10、9、8位置的数字，此时可以在第8个位置放置8.
…

用一个数组标记当前的数字是否已经被使用过了。
int book[10]; //一开始的时候没有被使用，初始化值为0.使用过了之后标记为1.
int a[10]; // 表示这10个需要放置数字的位置。
深度优先搜索：

void dfs(int step) {
    for (int i = 0; i <= 9; i++) {
        if (book[i] == 0) { //如果当前数字i没有被使用过
            a[step] = i; //就把当前位置放上这个数字i
            book[i] = 1; //同时不要忘记把book[i]标记为1
            dfs(step + 1); //深度优先搜索下一步
            book[i] = 0; //表示收回当前的数字
        }
    }
}


还有一个循环出口没有写。从step = 0开始执行，当当前的步骤已经step == 10的时候，
因为我们需要考虑的是0~9位置的摆放数字情况，当step时候不用执行，可以return作为出口了。
因为题目要求我们输出第n个全排列的组合是什么，那么
int cou = 0;
每当 step == 10 一组全排列完成的时候，
cou++;
直到 cou == n 的时候输出a数组中所有的数字。
所以代码描述为：


if (step == 10) {
    cou++;
    if (cou == n) {
        for (int i = 0; i <= 9; i++) {
            cout << a[i];
        }
    }
    return;
}


该题的解答完整代码如下：


#include <iostream>
using namespace std;
int n;
int book[10];
int a[10];
int cou = 0;
void dfs(int step) {
    if (step == 10) {
        cou++;
        if (cou == n) {
            for (int i = 0; i <= 9; i++) {
                cout << a[i];
            }
        }
        return;
    }
    
    for (int i = 0; i <= 9; i++) {
                if (book[i] == 0) {
                        a[step] = i;
                        book[i] = 1;
                        dfs(step + 1);
                        book[i] = 0;
                    }
            }
}

int main() {
        cin >> n;
        dfs(0);
      return 0;
}

void dfs(int step) {

for (int i = 0; i <= 9; i++) {

if (book[i] == 0) { //如果当前数字i没有被使用过

a[step] = i; //就把当前位置放上这个数字i

book[i] = 1; //同时不要忘记把book[i]标记为1

dfs(step + 1); //深度优先搜索下一步

book[i] = 0; //表示收回当前的数字

}

还有一个循环出口没有写。从step = 0开始执行，当当前的步骤已经step == 10的时候，

因为我们需要考虑的是0~9位置的摆放数字情况，当step时候不用执行，可以return作为出口了。

因为题目要求我们输出第n个全排列的组合是什么，那么

int cou = 0;

每当 step == 10 一组全排列完成的时候，

cou++;

直到 cou == n 的时候输出a数组中所有的数字。

所以代码描述为：

if (step == 10) {

cou++;

if (cou == n) {

for (int i = 0; i <= 9; i++) {

cout << a[i];

}

return;

}

该题的解答完整代码如下：

#include <iostream>

using namespace std;

int n;

int book[10];

int a[10];

int cou = 0;

void dfs(int step) {

if (step == 10) {

cou++;

if (cou == n) {

for (int i = 0; i <= 9; i++) {

cout << a[i];

}

return;

}

for (int i = 0; i <= 9; i++) {

if (book[i] == 0) {

a[step] = i;

book[i] = 1;

dfs(step + 1);

book[i] = 0;

}

int main() {

cin >> n;

dfs(0);

return 0;

}

在wordpress中使用 markdown：wp-markdown插件的使用方法

仪表盘 -> 插件 -> 安装插件 -> 搜索 wp-markdown.

下载该wordpress插件 -> 安装 -> 插件选项中启用wp-markdown插件
Snip20160202_235

启用：仪表盘 -> 设置 -> 撰写 -> Enable MarkDown for: 文章

Snip20160202_231