目录
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int n;
int a[10];
int main()
{
cin >> n;
int cnt = 1;
//可以使用字符的方式存储
// for(int i = 0; i < n;i++)
// {
// char tmp;
// cin >> tmp;
// a[i] = tmp - '0';
// }
//也可以就使用常规的存储方式，然后反转
int x;
cin >> x;
int i = 0;
int xx = x;
while(xx)
{
a[i++] = xx % 10;
xx /= 10;
}
//反转
reverse(a,a+n);
while(prev_permutation(a,a+n)) cnt++;
cout << cnt<< endl;
return 0;
}
解法二：
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int fac[]={1,1,2,6,24,120,720,5040,40320,362880};//定义康托展开函数中的阶乘
char s[32];
int n;
int Contor(char s[],int n)
{
int ans=0;
for(int i = 0;i < n;i++)
{
int smaller=0;//统计当前位置的右侧的数据中，比当前位置的数据小的个数
for(int j= i+1 ;j<n;j++)
if(s[i] > s[j])smaller++;
//带入康拓展开计算式
ans += smaller*fac[n-i-1];
}
return ans+1;
}
int main()
{
cin>>n;
cin>>s;
cout<<Contor(s,n);
return 0;
}
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1010;
char g_paper[N][N],g_word[N][N],g_tmp[N][N];
//模拟旋转
void swapSt(char g_paper[N][N],int n)
{
for(int i = 0; i < n;i++)
for(int j = 0; j < n;j++)
g_tmp[j][n-i-1] = g_paper[i][j];
for(int i = 0; i <n;i++)
for(int j = 0; j < n; j++)
g_paper[i][j] = g_tmp[i][j];
}
//常规的模拟
int main()
{
int n;
cin>>n;
//输入透明纸的状态
for(int i = 0; i < n;i++)
for(int j = 0; j < n;j++)
cin >> g_paper[i][j];
//输入字母表
for(int i = 0; i < n;i++)
for(int j = 0; j < n;j++)
cin >> g_word[i][j];
//枚举四次转换+统计结果
for(int i = 0; i < 4; i++)
{
for(int j = 0; j <n;j++)
for(int k = 0; k < n;k++)
if(g_paper[j][k] == 'O') cout << g_word[j][k];
//90度抓换
swapSt(g_paper,n);
}
return 0;
}
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* searchBST(TreeNode* root, int val) {
//根据二叉树的性质来吧
//特使情况处理
if(root == nullptr) return nullptr;
//返回结果
if(root->val == val) return root;
//递归进去继续找
return (val < root->val ? searchBST(root->left,val):searchBST(root->right,val));
}
};
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int ans = -1;
void dfs(TreeNode* root, int &k)
{
if(!root) return;
dfs(root->left,k);
k --;
if(k == 0) ans = root->val;
dfs(root->right,k);
}
int kthSmallest(TreeNode* root, int k) {
dfs(root,k);
return ans;
}
};
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* dfs(vector<int> &nums,int l ,int r)
{
//持续找中点值，中点的左边是左子树，右边是右子树
if(l > r) return nullptr;
int mid = (l+r) >> 1;
//将中点处理为一个结点
TreeNode* root_node = new TreeNode(nums[mid]);
//中点左边的数据归结为左子树的内容，递归进去按照类似的逻辑处理
root_node->left = dfs(nums,l,mid-1);
root_node->right = dfs(nums,mid+1,r);
return root_node;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
int n = nums.size();
int l = 0,r = n - 1;
return dfs(nums,l,r);
}
};
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> tmp;
TreeNode* dfs(vector<int> &nums,int l,int r)
{
if(l > r) return nullptr;
int mid = (l + r) >> 1;
TreeNode* node = new TreeNode(nums[mid]);
//递归去加载平衡二叉树的左子树和右子树
//比当前中点小的是左子树，比当前中点大的是右子树
node->left = dfs(nums,l,mid-1);
node->right = dfs(nums,mid+1,r);
return node;
}
void to_arr(TreeNode *node)
{
if(!node) return;
to_arr(node->left);
tmp.push_back(node->val);
to_arr(node->right);
}
TreeNode* balanceBST(TreeNode* root) {
//先把当前的树的信息存放到数组中
tmp.clear();
TreeNode* m = root;
to_arr(m);
//现在就是和上一题一样的操作了
int n = tmp.size();
int l = 0 , r = n-1;
return dfs(tmp,l,r);
}
};
