首页 > 试题广场 >

十字斩-研发

[编程题]十字斩-研发

热度指数：1265 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 64M，其他语言128M
算法知识视频讲解

游戏工程师小明购买了VR设备之后爱上了体感游戏，而最近他把他的业余时间花在了一款叫十字斩的游戏里。当你戴上VR眼镜启动游戏后，先选择一首音乐，然后会发现有一个N*N的方阵呈现在你的眼前，方阵的每个格子上都有一个数字。然后伴随着音乐节拍，你需要按照时机对方阵进行一次十字斩击（同时斩掉一行和一列，而且选好了行列后不能斩到选定行列之外的格子）。斩击完了之后，矩阵会收缩成一个（N-1）*（N-1）的方阵。

特别的，若该次十字斩斩到的格子数字和是本次所有十字可能里最大的，则会获得一个Perfect，如果N次十字斩都是Perfect，则可以获得FullCombo的成就。但小明的心算能力不行，至今还未能获得FullCombo的成就。所幸初始数字方阵与音乐是一一对应的，所以小明可以通过预先计算十字斩的位置然后背下来，游玩的时候根据记忆去进行十字斩位置的选择即可。

小明上了一天班已经不想写代码了，所以他拜托你来写一个程序为他计算出十字斩的方案。

输入描述:

每个输入数据包含一个测试点。

第一行为一个正整数N，方阵的大小。0 < N <= 500

接下来N行，每行有N个数字，第i行第j个数字表示方阵i行j列上的数字是多少，对于每个数字，保证是非负整数且范围在[0, 65535]内。

输出描述:

输出N行，每行两个整数n，m，第i行的n，m表示第i次斩击时，斩击第n行和第m列的数字和是最大的。注意如果此时有多种方案，输出n最小的（更小的数字更方便小明记忆），如果还有多种方案，输出m最小的。

而且n、m的坐标是对于当前的（N + 1 – i）大小方阵而言，并不是对于一开始N*N大小的方阵而言，更加详细的说明参见下方样例说明。

示例1

输入

输出

2 2
1 2
1 1

说明

对于第一轮，我们斩击2行2列、2行3列、3行2列、3行3列的数字和都是最大的为30（行列重复的那个格子的数字并不会被计算两次），但因为希望n和m都最小，所以我们的斩击选择为2 2

斩击之后剩余的上下左右四个矩阵收缩为新的矩阵

1 0

0 10

此时最优的斩击选择就是1 2 (注意是新方阵下的坐标，而非原方阵的第1行3列)

然后剩下一个1*1的方阵，只有唯一的斩击选择1 1了

算法知识视频讲解

已注销

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
void tencut(vector<vector<int>>& vec, int size) {
	pair<int, int>cut{ 0,0 };
	int m = size;
	if (m == 1)cout << 1 << " " << 1 << endl; //如果只有1的大小，输出1,1
	else if (m > 0) {
		int row = 0, colum = 0, maxNum = 0;
		vector<vector<int>>sum(m, vector<int>(2));// 记录每行每列的总和，m*2个数，一列是行和，一列是列合，可以将m个求和转换为常数的减法
		for (int i = 0; i < m; i++) {
			int colsum = 0, rowsum = 0;
			for (int j = 0; j < m; j++) {
				rowsum += vec[i][j];
				colsum += vec[j][i];
			}
			sum[i][0] = rowsum;
			sum[i][1] = colsum;
		}
		for (int i = 0; i < m; i++) { //用每处的行和＋列和－自身得到十字合
			for (int j = 0; j < m; j++) {
				int alsum = sum[i][0] + sum[j][1] - vec[i][j];
				if (alsum > maxNum) {  //寻找最小十字合输出结果
					maxNum = alsum;
					row = i; colum = j;
				}
			}
		}
		cout << row + 1 << " " << colum + 1 << endl;
		int rr = 0, cc = 0;//在原数组上进行修改，减少空间复杂度
		for (int i = 0; i < m; i++) {
			if (i == row)continue;
			cc = 0;
			for (int j = 0; j < m; j++)
			{
				if (j == colum)continue;
				vec[rr][cc] = vec[i][j];
				cc++;
			}
			rr++;
		}
		tencut(vec, m - 1);//进行递归
	}
}
int main() {
	int size = 0;
	while (cin >> size) {
		vector<vector<int>>vec(size, vector<int>(size, 0));
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size; j++) {
				cin >> vec[i][j];
			}
		}
		tencut(vec, size);% 每次十字斩的大小
	}
	return 0;
}

发表于 2021-08-06 13:53:15 回复(0)

牛客小浩

更改之后的需要将每行每列的值提前求出来

代码：

#include<iostream>
#include<bits/stdc++.h>
#include<algorithm>
using namespace std;
/* int getsum(int x,int y,deque<deque<int>> box){
    int x_size = box[x].size();
    int x_sum=0,y_sum=0;
    for(int k = 0;k<x_size;k++){
        x_sum  += box[x][k];
        y_sum  += box[k][y];
    }
    return x_sum+y_sum - box[x][y];
} */

int main(){
    int n; cin>>n;
    //数据存入
    deque<deque<int>> box(n,deque<int>(n,0));//初始化矩阵
    for(int i=0;i<n;i++){
       for(int j=0;j<n;j++){
           int temp;
           cin>>temp;
           box[i][j] = temp;
       }
    }
    //处理数据
    while(n>0){
        int x=0,y=0;
        //求第i行 第j列的值
        int max_sum = 0;
        //数组行和列的值 应该在前面就进行得到
        int x_sum=0,y_sum = 0;
        vector<int> p_x(n,0);
        vector<int> p_y(n,0);
        for(int k = 0;k<n;k++){
           for(int p=0;p<n;p++){
               p_x[k] += box[k][p];
               p_y[p] += box[k][p];
           }
        }
        for(int l=0;l<n;l++){
            for(int h=0;h<n;h++){
                int temp_max = p_x[l]+ p_y[h]- box[l][h];
                if(temp_max>max_sum){
                    //第一大于的数据
                    x=l;
                    y=h;
                    max_sum = temp_max;
                };
            }
        }
        //需要删除 x 和y 行的数据
        cout<<(x+1)<<" "<<(y+1)<<endl;
        n--;
        //对于deque进行删除
        //删除一行
        box.erase(box.begin()+x);
        //删除列
        int b_size = box.size();
        for(int i=0;i<b_size;i++){
            box[i].erase(box[i].begin()+y);
        }
    }

    return 0;
}

以下的复杂度太高吗

超时了

#include<iostream>
#include<bits/stdc++.h>
#include<algorithm>
using namespace std;
int getsum(int x,int y,deque<deque<int>> box){
    int x_size = box[x].size();
    int x_sum=0,y_sum=0;
    for(int k = 0;k<x_size;k++){
        x_sum  += box[x][k];
        y_sum  += box[k][y];
    }
    return x_sum+y_sum - box[x][y];
}

int main(){
    int n; cin>>n;
    //数据存入
    deque<deque<int>> box(n,deque<int>(n,0));//初始化矩阵
    for(int i=0;i<n;i++){
       for(int j=0;j<n;j++){
           int temp;
           cin>>temp;
           box[i][j] = temp;
       }
    }
    //处理数据
    while(n>0){
        int x=0,y=0;
        //求第i行 第j列的值
        int max_sum = 0;
        for(int l=0;l<n;l++){
            for(int h=0;h<n;h++){
                int temp_max = getsum(l, h, box);
                if(temp_max>max_sum){
                    //第一大于的数据
                    x=l;
                    y=h;
                    max_sum = temp_max;
                };
            }
        }
        //需要删除 x 和y 行的数据
        cout<<(x+1)<<" "<<(y+1)<<endl;
        n--;
        //对于deque进行删除
        //删除一行
        box.erase(box.begin()+x);
        //删除列
        int b_size = box.size();
        for(int i=0;i<b_size;i++){
            box[i].erase(box[i].begin()+y);
        }
    }

    return 0;
}

编辑于 2021-08-06 16:49:35 回复(0)

C/C++

TimeFlow

1. 使用vector保存数据，可以直接erase删除元素；

2. 建立两个数组rowSum，columnSum，分别保存每一个行的和与每一列的和，这一步可以边输入边完成，不会增加额外的操作时间；

3. 每次十字斩后，直接在原来的rowSum和columnSum的基础上，给每个行列的和减去被斩掉的元素值，并从rowSum，columnSum中删除这一行和这一列的和值；

# include<bits/stdc++.h>
using namespace std;

int main(){
    int N;
    cin>>N;
    vector<int> rowSum(N,0);
    vector<int> columnSum(N,0);
    vector<vector<int> > matrix;
    
    for(int i=0;i<N;i++)
    {
        vector<int> row; // 保存这一行的元素
        for(int j=0;j<N;j++){
            int num;
            cin>>num;
            row.push_back(num);
            rowSum[i]+=num; // 累加该行的值
            columnSum[j]+=num; // 累加该列的值
        }
        matrix.push_back(row);
    }
    
    while(N>0){
        int max=0,row,column;
        for(int j=0;j<N;j++){
            for(int k=0;k<N;k++){
                int sum=rowSum[j]+columnSum[k]-matrix[j][k]; // 计算该元素对应的十字斩的值
                if(sum>max){
                    max=sum;
                    row=j;column=k; // 记录最大十字斩和所对应的行与列
                }
            }
        }
        for(int j=0;j<N;j++){
            rowSum[j] -= matrix[j][column]; // 更改十字斩删除行列之后的每一行的值（减去被删掉的值）
            columnSum[j] -= matrix[row][j]; // 更改十字斩删除行列之后的每一列的值（减去被删掉的值）
        }
        rowSum.erase(rowSum.begin()+row); // 删除该行对应的和
        columnSum.erase(columnSum.begin()+column); // 删除该列对应的和
        
        cout<<row+1<<" "<<column+1<<endl;
        
        matrix.erase(matrix.begin()+row); // 删除矩阵中被十字斩的行
        int i=0;
        while(i<N-1){
            matrix[i].erase(matrix[i].begin()+column); // 依次删除每一行中，被十字斩了的列元素
            i++;
        }
        N--;
       
    }
    return 0;
}

编辑于 2022-04-14 14:52:53 回复(0)

一直吃一直胖

将每行和每列值的和保存下来，每次遍历每个点找最大的交叉点，删除之后保存的相应的行和列也要删除，使用vector就可以实现，这样不断遍历再加删除就可以实现题目要求。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
int n;
int main(){
	cin>>n;
	int val;
	vector<vector<int> >a;
	vector<int>row(n,0);
	vector<int>col(n,0);
	for(int i=0;i<n;i++){
		a.push_back({});
		for(int j=0;j<n;j++){
			cin>>val;
			a[i].push_back(val);
			row[i]+=val;
			col[j]+=val;
		}
	}
	while(n){
		int maxx = 0,r,c;
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				int sum = row[i]+col[j]-a[i][j];
				if(sum>maxx){
					maxx = sum; r = i; c = j;
				}
			}
		}
		cout<<r+1<<' '<<c+1<<'\n';
		for(int i=0;i<n;i++){
			row[i]-=a[i][c];
			col[i]-=a[r][i];
		}
		row.erase(row.begin()+r);
		col.erase(col.begin()+c);
		a.erase(a.begin()+r);
		for(int i=0;i<n-1;i++){
			a[i].erase(a[i].begin()+c);
		}
		n--;
	}
	return 0;
}

发表于 2022-06-17 19:38:16 回复(0)

RichardPan0000

做法还是模拟它题意。使用rowSums和columnSums来表示行和、列和，但是要用List来进行删除元素和rowSums和columnSums，而不是数组，因为数组每次还得重新遍历一遍，而且还得用ArrayList，LinkedList效率低，这是因为我用的get(index)，remove(index)，set()等都是基于下标的。

// 重新弄数组那种做法太麻烦，我还是直接用list来解决
import java.util.*;

public class Main {

// 重新弄数组那种做法太麻烦，我还是直接用list来解决


    static List<Integer> rowSums;
    static List<Integer> columnSums;
    static List<List<Integer>> map;
    static List<int[]> ret;
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        map=new ArrayList<List<Integer>>();
        for(int i=0;i<n;i++){
            map.add(new ArrayList<Integer>());
        }
        // 接收数据
        rowSums=new ArrayList<Integer>();
        columnSums=new ArrayList<Integer>();
        int[] rowS=new int[n];
        int[] columnS=new int[n];
        // 得到graph和行和，列和
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                int num=sc.nextInt();
                map.get(i).add(num);
                rowS[i]+=num;
                columnS[j]+=num;
            }
        }

        // 转换为列表存储
        for(int i=0;i<n;i++){
            rowSums.add(rowS[i]);
            columnSums.add(columnS[i]);
        }


        ret=new ArrayList<int[]>();
        find(n);
        for(int[] a:ret){
            System.out.println(a[0]+" "+a[1]);
        }

    }

    // 寻找行和，列和最大的数,返回个数组，表示行和列
    public static void find(int n){
        while(ret.size()!=n){ // 说明还没有斩击完
            int row=0;
            int rowMAX=0,cloumnMAX=0;
            int column=0;
            int MAX=0;
            for(int i=0;i<rowSums.size();i++){
                for(int j=0;j<columnSums.size();j++) {
                    int tmp = rowSums.get(i) + columnSums.get(j) - map.get(i).get(j);
                    if(tmp>MAX){
                        MAX=tmp;
                        row=i;
                        column = j;
                    }
                }
            }



            ret.add(new int[]{row+1,column+1});
            // 找到需要删除的行和列之后，进行 删除操作
            slash(row,column);

        }
    }


    // todo 完成模拟，行和，列和的变化，同时进行 map的变化
    public static void slash(int row,int column){

        // 首先是 rowSums和columnSums先变化
        for(int i=0;i<rowSums.size();i++){
            rowSums.set(i,rowSums.get(i)-map.get(i).get(column));  // 每行减去相应元素
        }

        for(int i=0;i<columnSums.size();i++){
            columnSums.set(i,columnSums.get(i)-map.get(row).get(i));  // 每列减去相应元素
        }

        //删除相应行和列
        rowSums.remove(row);
        columnSums.remove(column);

        // map则是先删除每行中column列的元素，再删除row行
        for(int i=0;i<map.size();i++){
            map.get(i).remove(column);
        }
        map.remove(row);
    }
}


通过全部用例
运行时间
1472ms
占用内存
28208KB

发表于 2022-05-14 22:01:14 回复(0)

感谢信收割机这个名字谁占用了

## Python不配？？？直接就超时？
n = int(input())
string_list = []
for i in range(n):
    string = list(map(int,input().split(' '))) # list(map(int, results))
    string_list.append(string)
list_hang =[i for i in range(0,1+n)]
list_lie =[i for i in range(0,n+1)]
hang = [ sum(string_list[i]) for i in range(n)]
lie = [0 for i in range(n)]
for i in range(n):
    for j in range(n):
        lie[i] += string_list[j][i]

for p in range(n):
    max_key = -float('inf')
    key_xy= [0,0]
    for i in range(n):
        for j in range(n):
            if hang[i]+lie[j]-string_list[i][j]>max_key:
                key_xy = [i,j]
                max_key = hang[i]+lie[j]-string_list[i][j]


    for i in range(n):
        hang[i]-=string_list[i][key_xy[1]]
        lie[i] -= string_list[key_xy[0]][i]

    for i in range(n):
        string_list[i][key_xy[1]]=0
        string_list[key_xy[0]][i]=0
    hang[key_xy[0]] = 0
    lie[key_xy[1]] = 0
    for i in range(key_xy[0]+1,n+1):
        list_hang[i]-=1
    for i in range(key_xy[1]+1,n+1):
        list_lie[i]-=1
    print(list_hang[key_xy[0]]+1 , list_lie[key_xy[1]]+1)

发表于 2022-03-17 13:39:11 回复(1)

进击的花卷

斩击+收缩矩阵

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);//输入
        int n = sc.nextInt();
        int[][] nums = new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                nums[i][j] = sc.nextInt();
            }
        }
        while(n>0){
            nums=mainHelper(nums,n);
            n--;
        }
    }
    /**
    * 斩击
    */
    private static int[][] mainHelper(int[][] nums,int n){
        int[] line = new int[n];
        int[] column = new int[n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                line[i]+=nums[i][j];
                column[i]+=nums[j][i];
            }
        }
        int l1=0,l2=0;
        int max=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                int temp=line[i]+column[j]-nums[i][j];
                if(temp>max){
                    l1=i;
                    l2=j;
                    max=temp;
                }
            }
        }
        System.out.println((l1+1)+" "+(l2+1));
        return getNewNums(nums,n,l1,l2);
    }
    /**
    * 收缩矩阵
    */
    private static int[][] getNewNums(int[][] nums,int n,int l1,int l2){
        int[][] nums1 = new int[n-1][n-1];
        for(int i=0;i<l1;i++){
            for(int j=0;j<l2;j++){
                nums1[i][j]=nums[i][j];
            }
        }
        for(int i=l1+1;i<n;i++){
            for(int j=0;j<l2;j++){
                nums1[i-1][j]=nums[i][j];
            }
        }
        for(int i=0;i<l1;i++){
            for(int j=l2+1;j<n;j++){
                nums1[i][j-1]=nums[i][j];
            }
        }
        for(int i=l1+1;i<n;i++){
            for(int j=l2+1;j<n;j++){
                nums1[i-1][j-1]=nums[i][j];
            }
        }
        return nums1;
    }
}

发表于 2022-03-17 09:11:36 回复(0)

有间猫

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
    int n;
    cin >> n;
    unsigned int **p = new unsigned int*[n]; // 定义矩阵
    unsigned int *rowSum = new unsigned int[n]; // 定义每行的和
    unsigned int *colSum = new unsigned int[n]; // 每列的和
    memset(rowSum, 0, n * sizeof(unsigned int));
    memset(colSum, 0, n * sizeof(unsigned int));
    
    for(int i = 0; i < n; ++i)
        p[i] = new unsigned int[n];
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < n; ++j)
        {
            cin >> p[i][j]; 
            rowSum[i] += p[i][j];
            colSum[j] += p[i][j];
        }
    }
    bool *cutRow = new bool[n]; // 被斩去的行
    bool *cutCol = new bool[n]; // 被斩去的列
    memset(cutRow, 0, n * sizeof(bool));
    memset(cutCol, 0, n * sizeof(bool));
    
    for(int k = 0; k < n; k++)
    {
		int mx = 0, my = 0, max = 0;
			
		for(int i = 0; i < n; ++i)
		{
			if(cutRow[i]) // 如果改行被斩去 则跳过
				continue;
			for(int j = 0; j < n; ++j)
			{
				if(cutCol[j]) // 如果该列被斩去 跳过
					continue;
				int tmp = rowSum[i] + colSum[j] - p[i][j];
				if(tmp > max)
				{
					max = tmp;
					mx = i;
					my = j;
				}
			}
		}
		
        int ax = 0, ay = 0;
        // 更新每行每列的和
	    for(int i = 0; i < n; ++i)
	    {
	    	if(!cutCol[i])
	    	{
	        	colSum[i] -= p[mx][i];
	        	if(i < my) ay++; // 获取斩去的是哪列
			}
	        if(!cutRow[i])
	        {
	        	rowSum[i] -= p[i][my];
	        	if(i < mx) ax++; // 行
			}
	    }
		cutRow[mx] = cutCol[my] = true;
	    rowSum[mx] = colSum[my] = 0;
	    //cout << ax+1 << ends << ay+1 <<endl;
		printf("%d %d\n", ax + 1, ay + 1);
	}
	delete[] cutRow;
	delete[] cutCol;
}

发表于 2022-02-14 23:12:41 回复(0)

zwywz

#include<iostream>
#include<vector>
#define INT_MIN -2147483647
using namespace std;
class Solution {
public:
	void cross_target(vector<vector<int>> &G) {
		int n = G.size();
		vector<int>sum_line(n), sum_col(n);
		vector<int>prifix_line(n), prifix_col(n);
		int	x = 0,y = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				sum_line[i] += G[i][j]; 
				sum_col[j] += G[i][j];
			}
		} 
		int t = n;
		while (t-- > 0) {
			int curmax = INT_MIN;
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					if (G[i][j] == -1) {
						continue;
					}
					if (sum_line[i] + sum_col[j] - G[i][j] > curmax) {
						curmax = sum_line[i] + sum_col[j] - G[i][j];
						x = i ; y = j;
					}
				}
			}
			cout <<x - prifix_line[x] + 1 << " " << y - prifix_col[y] + 1 << endl;
			for (int i = 0; i < n; i++) {
				sum_line[i] -= G[i][y] == -1 ? 0 : G[i][y];
				sum_col[i] -= G[x][i] == -1 ? 0 : G[x][i];
				G[x][i] = -1;
				G[i][y] = -1;
				if (i >= x)
					prifix_line[i]++;
				if (i >= y)
					prifix_col[i]++;
			}
			sum_line[x] = 0;
			sum_col[y] = 0;
		}
	}

};

int main() {
	Solution solu;
	int n;
	cin >> n;
	vector<vector<int>> nums(n, vector<int>(n));
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			cin >> nums[i][j];
		}
	}
	solu.cross_target(nums);

}

发表于 2021-08-07 15:36:51 回复(0)

OathSign

//额外一行一列保存和，只需在原数组修改
#include<iostream>
#include<vector>
using namespace std;
int main(){
    int N;
    cin>>N;
    vector<vector<int>> m(N+1, vector<int>(N+1,0));
    for(int i=1;i<=N;i++){
        int temp = 0;
        for(int j =1;j<=N;j++){
            cin>>m[i][j];
            temp+=m[i][j];
        }
        m[i][0] = temp;
    }
    for(int j=1;j<=N;j++){
        int temp = 0;
        for(int i=1;i<=N;i++){
            temp+=m[i][j];
        }
        m[0][j] = temp;
    }
    for(int n=0;n<N;n++){
        int maxi=1;
        int maxj=1;
        int curmax = -1;
        for(int i=1;i<=N;i++){
            for(int j =1;j<=N;j++){
                if((m[i][0]>=0 && m[0][j]>=0)&&(m[i][0] + m[0][j] - m[i][j] > curmax)){
                    maxi = i;
                    maxj = j;
                    curmax = m[i][0] + m[0][j] - m[i][j];
                }
            }
        }
        int resi = 0;
        int resj = 0;
        for(int i=1;i<=maxi;i++){
            if(m[i][0]>=0)
                resi++;
        }
        for(int j=1;j<=maxj;j++){
            if(m[0][j]>=0)
                resj++;
        }
        cout<<resi<<' '<<resj<<endl;
        for(int i=1;i<=N;i++){
            if(m[i][0]>=0){
                if(i!=maxi)
                    m[i][0] -= m[i][maxj];
                else
                    m[i][0] = -1;
            }
        }
        for(int j=1;j<=N;j++){
            if(m[0][j] >=0){
                if(j!=maxj)
                    m[0][j] -= m[maxi][j];
                else
                    m[0][j] = -1;
            }
        }

    }
    return 0;
}

编辑于 2021-08-06 16:53:14 回复(0)

maoxiaomao

Matlab代码O(n^3)复杂度....超时了

第一次O(n)是收缩矩阵的，内部两次O(n^2)是遍历二维矩阵

N=str2num(input('','s'));
A=zeros(N,N);
for i=1:N
    lines = strsplit(input('','s'));
    t=[];
    for j=1:N
        t(j)=str2num(lines{j});
    end
    A(i,:)=t;
end
for n=1:N                    %需要砍N次
    maxN=0;
    for u=1:size(A,1)
        for v=1:size(A,1)
            num=sum(A(u,:))+sum(A(:,v))-A(u,v);
            if num>maxN
                maxN=num;
                row_i=u;
                col_j=v;
            end
        end
    end
    fprintf('%d %d\n',row_i,col_j);
    tmp=zeros(size(A,1)-1,size(A,1)-1);
    ii=1;
    jj=1;
    for i=1:size(A,1)        %删除
        for j=1:size(A,1)
            if i~=row_i && j~=col_j
                tmp(ii,jj)=A(i,j);
                jj=jj+1;
                if jj>=size(A,1)
                    jj=1;
                end
            end
        end
        if i~=row_i
            ii=ii+1;
        end
    end
    A=tmp;                   %更新A
end

编辑于 2021-05-21 09:19:56 回复(0)