Question

我刚刚解决了一个关于leetcode的问题，要求我找到求和到给定目标的数字组合。我刚刚解决了它，但是我很难找到它的时间复杂度。请帮忙。

import java.util.*;
class Solution
{
    List<List<Integer>> result=new ArrayList();
    public List<List<Integer>> combinationSum2(int[] candidates, int target)
    {
        HashMap<List<Integer>,Integer> map=new HashMap();
        List<Integer> temp=new ArrayList();
        Arrays.sort(candidates);
        help(candidates,0,target,map,temp);
        return result;
    }
    private void help(int[] arr,int start,int target,HashMap<List<Integer>,Integer> storage,List<Integer> temp)
    {
        if(start>=arr.length)
            return;
        List<Integer> check=new ArrayList<>(temp);
        check.add(arr[start]);
        if(arr[start]==target)
        {

            if(storage.containsKey(check))
            {
                help(arr,start+1,target,storage,temp);
                return;
            }
            else
            {
                temp.add(arr[start]);
                result.add(temp);
                storage.put(temp,1);
                return;
            }
        }
        if(arr[start]>target)
        {
            return;
        }
        help(arr,start+1,target,storage,temp);
        help(arr,start+1,target-arr[start],storage,check);

    }
}

Answer 1

您通常有1个Arrays.sort(candidates) O(nlog(n))。您还具有1个递归和2个调用，应为O(2^n)。因此，最糟糕的情况应该是O(2^n)

（O1）说一种算法运行恒定时间，无论输入大小如何，我们称之为O（1）。

    int getFirst(int[] arr) {
       return arr[0]; //O(1)
    }

    Map<Integer, Integer> map = new HashMap(){{
      put(1, 10);
    }};

    map.get(1); //O(1)

O（n）如果运行线性时间。

      int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += n[i];
        }

O（logN）以对数时间运行

类似于二进制搜索https://en.wikipedia.org/wiki/Binary_search_algorithm

O（n ^ 2）2个嵌套循环。更多的嵌套迭代将导致O（n ^ 3）O（n ^ 4）...

for(int i = 0; i < n; i++) {
   for (int j = i; j < n; j++) {
      ...
  }
}

O（2 ^ n）每增加一个输入，它就会增长一倍。

public int fibo(int n) {
    if (n < 2) return n;
    return fibo(n - 2) + fibo(n - 1);
}

难以找到时间的复杂性

1 个答案: