C++程序以找出通过交换行和列可以生成的唯一矩阵的数量

假设我们有一个 n x n 矩阵。矩阵中的每个元素都是唯一的，并且是 1 到 n² 之间的整数。现在我们可以以任意数量和任意顺序执行以下操作。

• 我们选择矩阵中的任意两个整数 x 和 y，其中 (1 ≤ x

• 我们选择矩阵中的任意两个整数 x 和 y，其中 (1 ≤ x

• 我们必须注意 x + y ≤ k 并且这些值不能出现在相同的行和列中。

  立即学习“C++免费学习笔记（深入）”；

我们必须找出通过执行操作可以获得的唯一矩阵的数量。

android使用JSON进行网络数据交换 WORD版

本文档主要讲述的是android使用JSON进行网络数据交换；JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成，非常适合于服务器与客户端的交互。JSON采用与编程语言无关的文本格式，但是也使用了类C语言的习惯，这些特性使JSON成为理想的数据交换格式。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看

下载

因此，如果输入类似于 n = 3, k = 15, mat = {{4, 3, 6}, {5, 9, 7}, {1, 2, 8}}，那么输出将为36。

例如，选择的两个值是 x = 3 和 y = 5。如果交换列，所得矩阵将是 -

3 4 6
9 5 7
2 1 8

通过这种方式可以获得36个这样的独特矩阵。

为了解决这个问题，我们将遵循以下步骤 -

Define a function dfs(), this will take k, arrays ver and visited, one stack s.
   if visited[k] is non-zero, then:
      return
   visited[k] := true
   insert k into s
   for initialize iterator j := start of ver[k], when j is not equal to last element of ver[k], update (increase j by 1), do:
      dfs(*j, ver, visited, s)
Define an array f of size: 51.
f[0] := 1
for initialize i := 1, when i <= 50, update (increase i by 1), do:
   f[i] := (i * f[i - 1]) mod modval
Define an array e of size n
Define an array pk of size n
for initialize i := 0, when i < n, update (increase i by 1), do:
   for initialize j := i + 1, when j < n, update (increase j by 1), do:
      chk := 0
         for initialize l := 0, when l < n, update (increase l by 1), do:
            if (mat[i, l] + mat[j, l]) > k, then:
               chk := 1
               Come out from the loop
         if chk is same as 0, then:
             insert j at the end of pk[i]
             insert i at the end of pk[j]
          chk := 0
          for initialize l := 0, when l < n, update (increase l by 1), do:
             if (mat[l, i] + mat[l, j]) > k, then:
                chk := 1
                Come out from the loop
           if chk is same as 0, then:
               insert j at the end of e[i]
               insert i at the end of e[j]
resa := 1, resb = 1
Define an array v1 of size: n and v2 of size: n.
for initialize i := 0, when i < n, update (increase i by 1), do:
   v1[i] := false
   v2[i] := false
for initialize i := 0, when i < n, update (increase i by 1), do:
   Define one stack s.
   if not v1[i] is non-zero, then:
      dfs(i, pk, v1, s)
      if not s is empty, then:
         resa := resa * (f[size of s])
         resa := resa mod modval
for initialize i := 0, when i < n, update (increase i by 1), do:
   Define one stack s
   if not v2[i] is non-zero, then:
      dfs(i, e, v2, s)
      if not s is empty, then:
         resb := resb * (f[size of s])
         resb := resb mod modval
print((resa * resb) mod modval)

示例

让我们看看以下实现，以便更好地理解 -

#include 
using namespace std;
#define modval 998244353
const int INF = 1e9;
void dfs(int k, vector ver[], bool visited[], stack &s) {
   if(visited[k])
      return;
   visited[k] = true;
   s.push(k);
   for(vector :: iterator j = ver[k].begin(); j!=ver[k].end(); j++)
      dfs(*j, ver, visited, s);
}
void solve(int n, int k, vector> mat) {
   int f[51];
   f[0] = 1;
   for(int i = 1; i <= 50; i++) {
      f[i] = (i * f[i-1]) % modval;
   }
   vector e[n];
   vector pk[n];
   for(int i = 0; i < n; i++) {
      for(int j = i + 1;j < n; j++) {
         int chk = 0;
         for(int l = 0; l < n; l++){
            if((mat[i][l] + mat[j][l]) > k) {
               chk = 1;
               break;
            }
         }
         if(chk==0) {
            pk[i].push_back(j);
            pk[j].push_back(i);
         }
         chk = 0;
         for(int l = 0;l < n; l++) {
            if((mat[l][i] + mat[l][j]) > k){
               chk = 1;
               break;
            }
         }
         if(chk == 0) {
            e[i].push_back(j);
            e[j].push_back(i);
        }
      }
   }
   int resa = 1, resb = 1;
   bool v1[n], v2[n];
   for(int i = 0; i < n; i++) {
      v1[i] = false;
      v2[i] = false;
   }
   for(int i = 0;i < n; i++) {
      stack s;
      if(!v1[i]) {
         dfs(i, pk, v1, s);
         if(!s.empty()) {
             resa *= (f[s.size()]) % modval;
             resa %= modval;
         }
      }
   }
   for(int i = 0 ;i < n; i++) {
      stack s;
      if(!v2[i]){
         dfs(i, e, v2, s);
         if(!s.empty()) {
           resb *= (f[s.size()]) % modval;
            resb %= modval;
         }
      }
   }
   cout<< (resa * resb) % modval;
}
int main() {
   int n = 3, k = 15;
   vector> mat = {{4, 3, 6}, {5, 9, 7}, {1, 2, 8}};
   solve(n, k, mat);
   return 0;
}

输入

3, 15, {{4, 3, 6}, {5, 9, 7}, {1, 2, 8}}

输出

36