每日随性一道算法题（水手森巴脱离菜鸟之路）

2020-09-08

给你一个正整数的数组 A（其中的元素不一定完全不同），请你返回可在 一次交换（交换两数字 A[i] 和 A[j] 的位置）后得到的、按字典序排列小于 A 的最大可能排列。

如果无法这么操作，就请返回原数组。

示例 1：

输入：[3,2,1]
输出：[3,1,2]
解释：
交换 2 和

示例 2：

输入：[1,1,5]
输出：[1,1,5]
解释： 
这已经是最小排列

示例 3：

输入：[1,9,4,6,7]
输出：[1,7,4,6,9]
解释：
交换 9 和 7

示例 4：

输入：[3,1,1,3]
输出：[1,3,1,3]
解释：
交换 1 和 3

提示：

1. 1 <= A.length <= 10000
2. 1 <= A[i] <= 10000

我自己写的答案：

class Solution {
    public int[] prevPermOpt1(int[] A) {

         for(int i=A.length-1;i>0;i--) {
			 if(A[i-1] > A[i]) {
				 for(int j=A.length-1;j>i-1;j--) {
					 if(A[i-1] > A[j] && A[j-1] !=A[j]) {
						 A[i-1] = A[i-1] + A[j];
						 A[j] = A[i-1] - A[j];
						 A[i-1] = A[i-1] - A[j];
						 break;
					 }
				 }
				 break;
			 }
		 }
		 
		 
		return A;
    }
}

 

2020-09-19

序列的全排序（不考虑相同值问题）

package likou;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

public class Test {

	
	public static void main(String[] args) {
		int[] nums = {1,2,3};
		
		List<List<Integer>> res = new ArrayList();
		
		res = recursion(nums);

		for(int i = 0;i<res.size();i++) {
			List l = res.get(i);
			for(Object j:l) {
				
				System.out.print((int)j);
			}
			System.out.println("");
		}
		

	}
	//对序列的全排序
		/*状态变量：
		 * 1.递归到了第几层depth
		 * 2.已经选了哪些数path
		 * 3.布尔数组used
		 */
	public static List<List<Integer>> recursion(int[] nums){
		List<List<Integer>> res = new ArrayList();
		//双端队列，可以用来实现栈和队列的操作，每种增删查都对应两种方法（堆和队列）
		//用来看选了哪些元素
		Deque stack = new ArrayDeque<>();
		int len = nums.length;
		boolean[] used = new boolean[len];
		if(len == 0) {
			return res;
		}
		dfs(nums, stack, len, 0,used, res);
		
		
		return res;
	}
	//深度优先的递归
	public static void dfs(int[] nums,Deque stack,int len,int depth,boolean[] used,List<List<Integer>> res) {
		if(depth == len) {
			//加入到res集合里，记住一定要add(这里一定要new一个list)
			res.add(new ArrayList(stack));
			return;
		}
		for(int i = 0;i<len;i++ ) {
			if(used[i]) {
				continue;
			}
			stack.addLast(nums[i]);
			used[i] = true;
			dfs(nums, stack, len, depth + 1, used, res);
			stack.removeLast();
			used[i] = false;
		}
	}
	
	
	
}

 

 

 

 

 

 

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/previous-permutation-with-one-swap