OJ排序

最新推荐文章于 2024-07-07 12:41:40 发布
最新推荐文章于 2024-07-07 12:41:40 发布
阅读量494 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zj20165149/article/details/114440901
版权

文章目录

冒泡排序

import java.util.Scanner;

/**
 * 13 24 3 56 34 3 78 12 29 49 84 51 9 100
 */
public class Main {
    public static  void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        int[] nums=new int[N];
        for(int j=0;j<N;j++){
            nums[j]=sc.nextInt();
        }
        bubbleSort(nums);
        for(int j=0;j<N;j++){
            System.out.print(nums[j]+" ");
        }

    }

    /**
     *
     * @param arrays
     */
    public static void bubbleSort(int[] arrays){
        for(int i=0;i<arrays.length-1;i++){
            boolean flag=true;
            for(int j=0;j<arrays.length-1-i;j++){
                if(arrays[j]>arrays[j+1]){
                    swap(arrays,j,j+1);
                    flag=false;
                }


            }
            if (flag) break;
        }

    }
    public static void swap(int[] array,int i,int j){
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }
}

按照另一个数组排序（冒泡排序变形）

按照数值个数排序
Description

对给定数组中的元素按照元素出现的次数排序，出现次数多的排在前面，如果出现次数相同，则按照数值大小排序。例如，给定数组为{2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12}，则排序后结果为{3, 3, 3, 3, 2, 2, 2, 12, 12, 4, 5}。

Input

输入的第一行为用例个数；后面每一个用例使用两行表示，第一行为数组长度，第二行为数组内容，数组元素间使用空格隔开。

Output

每一个用例的排序结果在一行中输出，元素之间使用空格隔开。

Sample Input 1

1
4
2 3 2 5
Sample Output 1

2 2 3 5

public class Main {
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int T=sc.nextInt();
        for(int t=0;t<T;t++){
            int N=sc.nextInt();
            int arr[]=new int[N];
            for(int i=0;i<N;i++){
                arr[i]=sc.nextInt();
            }
            Map<Integer,Integer> map=sortByTime(arr,N);
            for(Map.Entry<Integer,Integer> entry:map.entrySet()){
                int mapKey = entry.getKey();
                int mapValue = entry.getValue();
                //打印
                for(int j=0;j<mapValue;j++){
                    System.out.print(mapKey+" ");
                }
            }
            System.out.println("");

        }
    }

    /**
     * 按照数字出现的次数进行排序
     * @param arr
     */
    private static Map<Integer,Integer> sortByTime(int[] arr,int n) {
       // Arrays.sort(arr);
        Map<Integer,Integer> map=new TreeMap<>();
        for(int i=0;i<n;i++){
            map.put(arr[i],map.getOrDefault(arr[i],0)+1);
        }
        Set<Integer> keySet=map.keySet();
        
        map.entrySet().stream().sorted(Map.Entry.comparingByValue());
        return map;
    }
}

插入排序

publi
c class Main {
    public  static void  main(String args[]){
        Scanner sc=new Scanner(System.in);
        int T=Integer.parseInt(sc.nextLine());
        for(int t=0;t<T;t++){

            String[] numStr=sc.nextLine().trim().split(" ");
            int nums[]=new int[numStr.length-1];
            int N=Integer.parseInt(numStr[0]);
            for(int i=0;i<nums.length;i++){
                nums[i]=Integer.parseInt(numStr[i+1]);
            }
            sort(nums);
            for(int i=0;i<N;i++){
                System.out.print(nums[i]);
                if(i!=nums.length-1) System.out.print(" ");
            }
            System.out.println("");

        }
    }

    /**
     * 插入排序
     * @param nums
     */
    static  void sort(int[] nums){
        for(int i=1;i<nums.length;i++){
            int temp=nums[i];
            int j;
            for(j=i;j>0&&nums[j-1]>temp;j--){
                nums[j]=nums[j-1];
            }
            nums[j]=temp;
        }
    }
}

希尔排序

shell排序,按照给定的间隔变化，打印排序结果。
知识点：
两种插入排序
1）简单插入排序：（稳定排序）
直接插入排序的排序思路是：每次将一个待排序的元素与已排序的元素进行逐一比较，直到找到合适的位置按大小插入。
2）希尔排序
按照步长进行分组，每组内进行希尔排序。

import java.util.Scanner;

/**
 * shell排序,按照给定的间隔变化，打印排序结果。
 * 第一行：用例个数T
 * 第二行 ：数组
 * 第三行 ：指定间隔，每个间隔用空格隔开
 *
 * Sample Input 1
 * 1
 * 49 38 65 97 76 13 27 49 55 4
 * 5 3
 *
 * Sample Output 1
 * 13 4 49 38 27 49 55 65 97 76
 */
public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int T = Integer.parseInt(sc.nextLine().trim());
        for (int t = 0; t < T; t++) {
            String[] s = sc.nextLine().trim().split(" ");
            int[] arr = new int[s.length];//保存数组
            for (int i = 0; i < s.length; i++) {
                arr[i] = Integer.parseInt(s[i]);
            }
            String[] s1 = sc.nextLine().trim().split(" ");
            int path[] = new int[s1.length];//保存步数
            for (int i = 0; i < path.length; i++) {
                path[i] = Integer.parseInt(s1[i]);
            }
            shellOrder(arr, path);
            //打印
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+" ");
            }
            System.out.println("");
        }
        sc.close();


    }


    private static void shellOrder(int[] arr, int[] path) {
        for (int i = 0; i < path.length; i++) {
            orderByPath(arr, path[i]);
        }
    }

    /**
     * 根据步长进行排序
     *
     * @param array
     * @param h
     */
    private static void orderByPath(int[] array, int h) {
        for (int i = h; i < array.length; i++) {
            for (int k = i; k < array.length; k += h) {
                //判断是否需要重新排序,如果小于k-h处的值，需要重新排序
                if (array[k] < array[k - h]) {
                    int tempValue = array[k];
                    int j = k;
                    for (; j >= i && tempValue < array[j - h]; j -= h) {
                        array[j] = array[j - h];
                    }
                    array[j] = tempValue;
                }
            }
        }
    }
}

计数排序

Description
实现计数排序，通过多次遍历数组，统计比每一个元素小的其它元素个数，根据该统计量对数据进行排序。
Input
输入的每一行表示一个元素为正整数的数组，所有值用空格隔开，第一个值为数值长度，其余为数组元素值。
Output
输出的每一行为排序结果，用空格隔开，末尾不要空格。

分析：此题的重点是统计比每个元素小的其他元素的个数。

import java.util.Scanner;

public class Main {
    public static void bsort(int array[])
    {
        int counts[]=new int[array.length];
        int newarray[]=new int[array.length];
        for(int i=0;i<array.length-1;i++)
            for(int j=i+1;j<array.length;j++)
                if(array[i]>=array[j])
                    counts[i]++;//计算小于等于array[i]的个数 加不加等号不影响结果
                else
                    counts[j]++;//计算大于array[j]的个数
        
        for(int i=0;i<array.length;i++)
            newarray[counts[i]]=array[i];//根据位置存放元素
        for(int i=0;i<newarray.length;i++)//按照题意输出结果
            if(i!=newarray.length-1)
                System.out.print(newarray[i]+" ");
            else
                System.out.println(newarray[i]);


    }
    public static void main(String args[])
    {
        Scanner in=new Scanner(System.in);
        String arr[]=in.nextLine().split(" ");//按照题意输入，注意第一个是元素个数
        int array[]=new int[arr.length-1];//保存要排序的数据
        for(int i=1;i<arr.length;i++)
            array[i-1]=Integer.parseInt(arr[i]);//将数据转换
        bsort(array);


    }
}

非递归归并排序

public class Main {
    static Scanner scanner=new Scanner(System.in);
    public static  void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        int[] nums=new int[N];
        for(int j=0;j<N;j++){
            nums[j]=sc.nextInt();
        }
        mergeSort(nums);
        for(int j=0;j<N;j++){
            System.out.print(nums[j]+" ");
        }

    }

    /**
     * 非递归归并排序
     * @param nums
     */

    private static void mergeSort(int[] nums) {
        //建立步长path
        int path=1;
        int n=nums.length;
        while(path<=n){
            //确定排序边界
            for(int i=0;i<n-path;i=i+path+path){
                int mid=Math.min(i+path-1,n-1);
                int right=Math.min(i+path*2-1,n-1);
                merge(nums,i,mid,right);
            }
            path=path*2;
        }

    }

    /**
     * 将子数组left到mid 以及 子数组 mid+1 right 进行合并
     * @param nums
     * @param left
     * @param mid
     * @param right
     */
    static void merge(int nums[],int left,int mid,int right){
        //建立辅助数组
        int length=right-left+1;
        int[] auxiliaryArray=new int[length];
        int i=left;
        int j=mid+1;
        int index=0;
        while(i<=mid&&j<=right){
            if(nums[i]<=nums[j]){
                auxiliaryArray[index++]=nums[i++];
            }else{
                auxiliaryArray[index++]=nums[j++];
            }
        }

        while(i<=mid){
            auxiliaryArray[index++]=nums[i++];
            i++;
        }

        while (j<=right) {
            auxiliaryArray[index++] = nums[j++];
        }

        //将辅助数组的结果填到原数组中
        for(int t=0;t<auxiliaryArray.length;t++){
            nums[left+t]=auxiliaryArray[t];
        }


    }
}

合并数组——n路归并——借助优先队列


import java.util.Scanner;
import java.util.PriorityQueue;
import java.util.Comparator;

/**
 * 描述：给定k个已经排好序的数组。arr[k][k]
 * 合并k个数组，并排好序。
 * 输入 ：第一行 T
 *       第二行 N 数组数量
 *       第三行 数组
 * 思路：使用堆。
 */

public class Main {


    public static void main(String[] args){

        Scanner sc=new Scanner(System.in);
        int T=sc.nextInt();
        for(int i=0;i<T;i++){
            int N=sc.nextInt();
            int [][]arr=new int[N][N];
            for(int j=0;j<N;j++) {
                for (int k = 0; k < N; k++){
                    arr[j][k] = sc.nextInt();
                }
            }
            int[] res = mergeKArrays(arr, N);
            //打印
            for(int j=0;j<res.length;j++){
                System.out.print(res[j]+" ");
            }
            System.out.println("");
        }
        sc.close();


    }

    static class Element{
        int row,col,val;
        public Element(int row, int col, int val) {
            this.row = row;
            this.col = col;
            this.val = val;
        }

    }
    public static int[] mergeKArrays(int[][] arr, int k){
        PriorityQueue<Element> queue=new PriorityQueue<>(k, new Comparator<Element>() {
            @Override
            public int compare(Element o1, Element o2) {
                return o1.val-o2.val;
            }
        });//默认小顶堆
        int[] res=new int[k*k];
        int index=0;
        //初始化
        for(int j=0;j<k;j++){
            queue.offer(new Element(j,0,arr[j][0]));
        }
        while(!queue.isEmpty()){
            //出队列
            Element e=queue.poll();
            res[index++]=e.val;
            if(e.col+1<k) queue.offer(new Element(e.row,e.col+1,arr[e.row][e.col+1]));
        }

        return res;

    }
}

倒置对的个数——归并排序应用

import java.util.Scanner;

/**
 * Description
 * 有一个由N个实数构成的数组，如果一对元素A[i]和A[j]是倒序的，即i<j但是A[i]>A[j]则称它们是一个倒置，
 * 设计一个计算该数组中所有倒置数量的算法。要求算法复杂度为O(nlogn)
 *
 * Input
 * 输入有多行，第一行整数T表示为测试用例个数，后面是T个测试用例，每一个用例包括两行，第一行的一个整数是元素个数，第二行为用空格隔开的数组值。
 *
 *
 * Output
 * 输出每一个用例的倒置个数，一行表示一个用例。
 *
 * Sample Input 1
 * 1
 * 8
 * 8 3 2 9 7 1 5 4
 *
 * Sample Output 1
 * 17
 * 思路：采用归并排序
 *
 */
public class Main {
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int T=sc.nextInt();
        for(int i=0;i<T;i++){
            int N=sc.nextInt();
            int a[]=new int[N];
            for(int j=0;j<N;j++) a[j]=sc.nextInt();
            System.out.println(mergeSort(a,0,a.length-1));
        }

    }

    public static int   mergeSort(int[] array,int start,int end){
        if(start>=end) return 0;
        int mid=(start+end)/2;
        return  mergeSort(array,start,mid)+mergeSort(array, mid+1, end)+merge(array,start,end,mid);
    }
    public static int  merge(int[] array,int left,int right,int mid){
        //合并
        int total=0;
        int i=left;//左
        int j=mid+1;//右侧
        int newArray[]=new int[right-left+1];
        int index=0;
        while(i<=mid&&j<=right){
            if(array[i]<=array[j]){
               newArray[index++]=array[i++];
            }else{
                newArray[index++]=array[j++];
                //则i比j要大，则i后面都比j大
                total+=mid-i+1;
            }
        }
        while(i<=mid){
            newArray[index++]=array[i++];
        }
        while (j<=right){
            newArray[index++]=array[j++];
        }
        //写回
        for(int k=0;k<right-left+1;k++){
            array[k+left]=newArray[k];
        }
        return  total;

    }

}

非递归快排

import java.util.Scanner;
import java.util.Stack;
/**
 * Input
 * 输入的每一行表示一个元素为正整数的数组，所有值用空格隔开，第一个值为数值长度，其余为数组元素值。
 * Output
 * 输出的每一行为排序结果，用空格隔开，末尾不要空格。
 *
 *
 * Sample Input 1
 * 13 24 3 56 34 3 78 12 29 49 84 51 9 100
 * Sample Output 1
 * 3 3 9 12 24 29 34 49 51 56 78 84 100
 */
public class Main {
    static Scanner scanner=new Scanner(System.in);
    public static  void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        int[] nums=new int[N];
        for(int j=0;j<N;j++){
            nums[j]=sc.nextInt();
        }
        quickSort(nums);
        for(int j=0;j<N;j++){
            System.out.print(nums[j]+" ");
        }

    }

    /**
     * 非递归快速排序
     * @param nums
     */
    private static void quickSort(int[] nums) {
        int low=0;
        int high=nums.length-1;
        int pivot;
        if (low >= high)
            return;
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(low);
        stack.push(high);
        while (!stack.empty()) {
            // 先弹出high,再弹出low
            high = stack.pop();
            low = stack.pop();
            pivot = partion(nums, low, high);
            // 先压low,再压high
            if (low < pivot - 1) {
                stack.push(low);
                stack.push(pivot - 1);
            }
            if (pivot + 1 < high) {
                stack.push(pivot + 1);
                stack.push(high);
            }
        }

    }


    /**
     * 根据分界点移动元素，并返回新的分界点
     * @return
     */
    static int partion(int[] array,int low,int high){//合并排序部分
        int tmp = array[low];
        while(low<high){
            while(low < high && array[high] >= tmp){
                --high;
            }
            if(low >= high){
                break;
            }else{
                array[low]= array[high];//交换小值去前面
            }

            while(low < high && array[low] <= tmp){
                ++low;
            }
            if(low >= high){
                break;
            }else{
                array[high] = array[low];//交换大值去后面
            }
        }
        array[low] = tmp;//枢值归位
        return low;
    }

}

递归快排

  private static void quickSort(int[] nums) {
        int low=0;
        int high=nums.length-1;
        quick(nums,low,high);
    }
    private static void quick(int nums[],int low,int high){
        if(low>=high) return;
        int pivot=partion(nums,low,high);
        quick(nums,low,pivot-1);
        quick(nums,pivot+1,high);


    }

按照数值个数排序

按照数值个数排序
Description

对给定数组中的元素按照元素出现的次数排序，出现次数多的排在前面，如果出现次数相同，则按照数值大小排序。例如，给定数组为{2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12}，则排序后结果为{3, 3, 3, 3, 2, 2, 2, 12, 12, 4, 5}。

Input

输入的第一行为用例个数；后面每一个用例使用两行表示，第一行为数组长度，第二行为数组内容，数组元素间使用空格隔开。

Output

每一个用例的排序结果在一行中输出，元素之间使用空格隔开。

Sample Input 1

1
4
2 3 2 5
Sample Output 1

2 2 3 5

public class Main {
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int T=sc.nextInt();
        for(int t=0;t<T;t++){
            int N=sc.nextInt();
            int arr[]=new int[N];
            for(int i=0;i<N;i++){
                arr[i]=sc.nextInt();
            }
            Map<Integer,Integer> map=sortByTime(arr,N);
            for(Map.Entry<Integer,Integer> entry:map.entrySet()){
                int mapKey = entry.getKey();
                int mapValue = entry.getValue();
                //打印
                for(int j=0;j<mapValue;j++){
                    System.out.print(mapKey+" ");
                }
            }
            System.out.println("");

        }
    }

    /**
     * 按照数字出现的次数进行排序
     * @param arr
     */
    private static Map<Integer,Integer> sortByTime(int[] arr,int n) {
       // Arrays.sort(arr);
        Map<Integer,Integer> map=new TreeMap<>();
        for(int i=0;i<n;i++){
            map.put(arr[i],map.getOrDefault(arr[i],0)+1);
        }
        Set<Integer> keySet=map.keySet();
        
        map.entrySet().stream().sorted(Map.Entry.comparingByValue());
        return map;
    }
}
嘤嘤怪QQQ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
oj成绩排序
GQCgg的博客
08-15 246
使用cmp简化排序
华为oj烙饼排序
01-09
【华为OJ烙饼排序】是华为在线测评平台（OpenJudge）上的一道高级编程题目，主要考察的是排序算法的应用和实现。烙饼排序（Flipping Sorting），也称为煎饼排序，是一种基于比较的排序算法，它的灵感来源于煎饼翻转...
SDUT OJ排序问题(冒泡)
qq_64246637的博客
03-12 84
SDUT OnlineJudge #include<iostream> using namespace std; void bobble_sort(int*a,int*b,int len); int main() { int a[11],b[11]; for(int i = 1;i<=10;i++) { cin>>a[i]; b[i]=i; } bobble_sort(a,b,10); for.
归并排序oj
最新发布
2303_79552392的博客
07-07 73
【代码】归并排序oj。
H106OJ排序算法士兵排序问题
weixin_56610281的博客
03-19 1598
Description： 有Ｎ个士兵(1≤Ｎ≤26)，编号依次为Ａ,Ｂ,Ｃ,…，队列训练时，指挥官要把一些士兵从高到矮一次排成一行，但现在指挥官不能直接获得每个人的身高信息，只能获得“P1比P2高”这样的比较结果(P1、P2∈Ａ,Ｂ,Ｃ,…,Ｚ,记为 P1>P2)，如”Ａ>Ｂ”表示Ａ比Ｂ高。 请编一程序，根据所得到的比较结果求出一种符合条件的排队方案。 （注：比较结果中没有涉及的士兵不参加排队） Input： 比较结果从文本文件中读入（文件由键盘输入），每个比较结果在文本文件中占
OJ-希尔排序
qq_40996062的博客
01-04 305
increment为每次相隔的距离，此过程是中间过程，可以把外循环改一下就变成希尔排序 希尔排序就是有递减间隔的插入排序 import java.util.Scanner; public class shellTest { public static void main(String[] args) { Scanner inScanner=new Scanner(System.in); int n=Integer.parseInt(inScanner.nextLine()); for
OJ快速排序
Never__Forget的博客
09-24 250
#include #include <stdlib.h> #include <stdio.h> using namespace std; int quick_select(int a[], int l, int r, int k) { int p = rand() % (r - l + 1) + l; int x = a[p]; { int t = a[p]; a[p] = a[r]; a[r] = t; } int i = l, j = r; while(i < j) {
OJ题之插入排序
Christine_Deng_的博客
01-01 291
文章目录DescriptionInputOutputSample Input 1 Sample Output 1 Solution????Review???? Description 实现插入排序。 Input 输入第一行为用例个数， 每个测试用例输入的每一行代表一个数组，其中的值用空格隔开，第一个值表示数组的长度。 Output 输出排序的数组，用空格隔开，末尾不要空格。 Sample Input 1 1 13 24 3 56 34 3 78 12 29 49 84 51 9 100 Sample O
OJ题之冒泡排序
Christine_Deng_的博客
01-01 321
文章目录DescriptionInputOutputSolution????Review???? Description ​ 实现冒泡排序。 Input ​ 输入的每一行表示一个元素为正整数的数组，所有值用空格隔开，第一个值为数值长度，其余为数组元素值。 Output ​ 输出的每一行为排序结果，用空格隔开，末尾不要空格。 Solution???? import java.util.Scanner; public class ojtest1_21{ static void swap(in
C语言不声明函数造成的错误（swust oj 排序查找）
boeface的博客
01-27 290
C语言不声明函数造成的错误（swust oj 排序查找） 问题描述 对N个学生的成绩按从大到小的顺序排序，N个学生的成绩整数用scanf 输入，输入的成绩在[0，100]之间。排序完成后，输入一个成绩，要求用逐个比较查找的方式找出该成绩是该组中第几个元素的值（即第几名）。如果该成绩不在数组中，则输出“no this score!”。 要求： 1、把排序算法写成函数形式，在主函数中输入N个数据，然后调用排序函数排序。 2、在排序过程中尽量减少数据的交换和移动。 3、把查找算法写成函数形式，在主函数中输入1个数
杭电oj绝对值排序
World peace的博客
11-13 717
绝对值排序 Problem Description 输入n(n&lt;=100)个整数，按照绝对值从大到小排序后输出。题目保证对于每一个测试实例，所有的数的绝对值都不相等。 Input 输入数据有多组，每组占一行，每行的第一个数字为n,接着是n个整数，n=0表示输入数据的结束，不做处理。 Output 对于每个测试实例，输出排序后的结果，两个数之间用一个空格隔开。每个测试实例占一行。 Sam...
希尔排序OJ
07-03
输入 测试数据不止一组，每组测试数据： １）先输入无序序列的整数个数n；(n不超过1000000) ２）然后连续输入n个整数； 若n的值输入为０值，则输入结束． ...与每组输入的测试数据相对应，输出其按从小到大排好序后...
python 爬虫基本使用——统计杭电oj题目正确率并排序
12-16
本篇文章将介绍如何使用Python的基础爬虫库Urllib和BeautifulSoup4来统计杭州电子科技大学（杭电）在线评测系统（Online Judge，简称OJ）的题目正确率并进行排序。下面我们将详细讨论这两个库的功能以及爬虫的基本...
OJ_整型字符串排序
05-16
在这个特定的题目“OJ_整型字符串排序”中，我们面临的是一个关于整型字符串排序的挑战。由于描述中提到只有资源文件而没有入口程序和测试用例，这意味着我们需要自己构建解决问题的算法并编写相应的代码。 整型...
西南科技大学SWUST OJ 数据结构 查找排序相关题解 查找排序.zip
01-01
数据结构与查找排序是计算机科学中的基础且关键的领域，它们在编程竞赛和在线判题系统（如SWUST OJ）中占据着重要的地位。西南科技大学的这些在线判题题目涵盖了多个查找和排序算法的应用，旨在帮助学生深入理解和...
【回溯算法 backtracking】
zj20165149的博客
02-09 1321
目录什么是回溯算法？？？从全排列问题开始理解回溯搜索算法总结回溯算法基础问题列表 什么是回溯算法？？？ 回溯算法（backtracking）是暴力搜索算法的一种。 这句话向我们揭示了回溯算法的用途：搜索，因此回溯算法也被称为回溯搜索算法。与“二分查找”、“线性查找”等“查找问题”不同的是，“搜索问题”完成一件事情有可能多种方法，而每一种方法又有多个步骤，回溯算法就是在不断尝试，以得到待求问题的...
leetcode 刷题总结【21-40】题
zj20165149的博客
02-13 411
目录30. 串联所有单词的子串 30. 串联所有单词的子串 这道题，首先会想到先求出可以匹配的字符串（排列组合），再找出其在原字符串的位置。 class Solution { public List<Integer> findSubstring(String s, String[] words) { int n=words.length; if...
OJ数学公式——乘方运算以及取模技巧
zj20165149的博客
03-06 353
import java.util.Scanner; /** * 实现Implement pow(A, B) % C.In other words, given A, B and C, find (A^B)%C * */ public class Main { static Scanner in=new Scanner(System.in); public static void main(String args[]){ int T=in.nextInt();
B004 DNA排序 Oj
10-18
好的，关于 B004 DNA排序 Oj，我可以为您提供一些帮助。这道题目是要求对一组 DNA 序列进行排序，排序规则是按照序列中逆序对的数量从小到大排序。逆序对指的是在一个序列中，如果存在两个元素 a[i] 和 a[j]，且 i ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值