小编Wal*_*alt的帖子

如何在O(n)时间内找到到达数组末尾的最小跳转次数

给定一个整数数组,其中每个元素表示可以从该元素向前进行的最大步数.编写一个函数来返回到达数组末尾的最小跳转次数(从第一个元素开始).如果元素为0,则无法移动该元素.

输入:arr [] = {1,3,5,8,9,2,6,7,6,8,9}
输出:3(1-> 3 - > 8 - > 9)

找到了从动态规划方法到其他线性方法的多种方法.我无法理解在时间上线性的方法.HERE是提出线性方法的链接.

我根本无法理解它.我能理解的是,作者建议做一个贪婪的方法,看看我们是否达到目的......如果没有那么回溯?

java arrays algorithm

16
推荐指数
2
解决办法
2万
查看次数

在 Java 中使用递归的字符串排列

我遇到了这篇文章,它非常努力地解释了打印所有字符串的递归解决方案。

public class Main {
    private static void permutation(String prefix, String str) {
        int n = str.length();
        if (n == 0)
            System.out.println(prefix);
        else {
            for (int i = 0; i < n; i++)
                permutation(prefix + str.charAt(i),
                        str.substring(0, i) + str.substring(i + 1));
        }
    }

    public static void main(String[] args) {
        permutation("", "ABCD");
    }
}
Run Code Online (Sandbox Code Playgroud)

但是当我们开始从堆栈中弹出时,我仍然无法获得该部分。例如,递归一直进行到permutation("ABCD",""),在基本情况下遇到并打印ABCD。但是现在会发生什么?我们permutation("ABC","D")从函数调用堆栈中弹出。我们如何处理这个等等?

有人可以帮忙解释一下吗?

另外,我需要一些有关此时间复杂度的指针。不像完整的计算,而是一些提示。

java string recursion permutation anagram

8
推荐指数
1
解决办法
4358
查看次数

空间优化的硬币变化解决方案

给定值N,如果我们想要改变N美分,并且我们每个S = {S1,S2,..,Sm}值硬币都有无限供应,我们可以通过多少方式进行更改?硬币的顺序无关紧要.

例如,对于N = 4和S = {1,2,3},有四个解:{1,1,1,1},{1,1,2},{2,2},{1, 3}.因此输出应为4.对于N = 10且S = {2,5,3,6},有五种解决方案:{2,2,2,2,2},{2,2,3,3}, {2,2,6},{2,3,5}和{5,5}.所以输出应该是5.

我在这里发现了3种方法.但是无法理解空间优化的动态编程方法,其中仅使用单维数组表[].

int count( int S[], int m, int n )
{
    // table[i] will be storing the number of solutions for
    // value i. We need n+1 rows as the table is consturcted
    // in bottom up manner using the base case (n = 0)
    int table[n+1];

    // Initialize all table values as 0
    memset(table, 0, sizeof(table));

    // Base case (If given value is …
Run Code Online (Sandbox Code Playgroud)

java algorithm dynamic-programming

8
推荐指数
1
解决办法
981
查看次数

以中间元素为枢轴的快速排序

我对快速排序的理解是

  1. 选择一个枢轴元素(在这种情况下,我选择中间元素作为枢轴)
  2. 在极端情况下初始化左右指针。
  3. 找到枢轴左侧的第一个大于枢轴的元素。
  4. 类似地找到枢轴右侧的第一个小于枢轴的元素
  5. 交换在 3 和 4 中找到的元素。
  6. 重复 3、4、5,除非左 >= 右。
  7. 对左右子阵列重复整个过程,因为现在将枢轴放置在其位置。

我确定我在这里遗漏了一些东西并且非常愚蠢。但上面似乎不适用于这个数组:

  8,7,1,2,6,9,10,2,11 pivot: 6  left pointer at 8, right pointer at 11
  2,7,1,2,6,9,10,8,11 swapped 2,8  left pointer at 7, right pointer at 10
Run Code Online (Sandbox Code Playgroud)

怎么办 ?它的右侧没有小于 6 的元素。7 怎么会走到 6 的右边?

quicksort

8
推荐指数
1
解决办法
4万
查看次数

找到增加的三元组,使得和小于或等于k

这个问题的更容易或更流行的版本是找到具有给定总和的三元组.但是这个提出了额外的条件.找到未排序数组中的所有三元组

d[i]+d[j]+d[k] <= t;   & d[i]<d[j]<d[k] where i<j<k
Run Code Online (Sandbox Code Playgroud)

是问题第一部分的解决方案.但有人可以建议我们如何扩展它以包括第二个条件.我能想到的唯一方法是在排序时执行自定义数据结构以存储原始元素索引以及数字.然后检查索引是否符合所包含链接中提到的算法返回的每个三元组的顺序.

java algorithm triplet

7
推荐指数
1
解决办法
1633
查看次数

Java中整数数组中哪个更昂贵的操作交换或比较

Java中整数数组中哪个更昂贵的操作交换或比较?或者他们都可以被认为是一样的?

上下文:对几乎已排序的数组进行排序(我不是在谈论 k 排序数组,其中每个元素从正确位置最多偏移 k)。即使我们使用插入排序,最后的比较次数也将与任何数组或最坏情况下的比较次数相同。不是吗?只是掉期会更少。如果我错了,请纠正。

java sorting time-complexity

5
推荐指数
1
解决办法
1678
查看次数

工作排序贪婪解决方案的最优性证明

在此作业排序问题中,我们如何证明贪婪方法将提供的解决方案是最佳解决方案?

此外,正如作者后来声称的那样,我也无法弄清楚O(n)解决方案

通过使用联合查找数据结构,可以将其优化为几乎O(n)。

algorithm greedy job-scheduling

5
推荐指数
1
解决办法
2535
查看次数

HashMap实现中的泛型

在Java实现中,我找到了

 transient Entry[] table; 
 which is initiated in constructor as
 table = new Entry[capacity];
Run Code Online (Sandbox Code Playgroud)

我知道并且理解不允许创建通用数组,但是我无法理解的是整个事情是如何工作的.我的意思是当我们做类似的事情

HashMap<Integer, String> hMap = new HashMap<Integer, String>();
Run Code Online (Sandbox Code Playgroud)

上面的代码如何导致创建一个类型的Entry数组 <Integer, String>

好吧,很少有人无法理解我的要求.重新说一下我要问的是做什么的重点

HashMap<Integer, String> hMap = new HashMap<Integer, String>();
Run Code Online (Sandbox Code Playgroud)

当它没有导致

Entry<Integer, String>
Run Code Online (Sandbox Code Playgroud)

java generics hashmap

0
推荐指数
1
解决办法
716
查看次数