- html - 出于某种原因,IE8 对我的 Sass 文件中继承的 html5 CSS 不友好?
- JMeter 在响应断言中使用 span 标签的问题
- html - 在 :hover and :active? 上具有不同效果的 CSS 动画
- html - 相对于居中的 html 内容固定的 CSS 重复背景?
假设我们有一个数组L [] = {4,1,2,6}。我们需要做的是将由字符A,R,M组成的字符串S作为输入,并应用以下算法:
for i from 1 to N do
if ith letter of S is 'R'
reverse L[i...N]
else if ith letter of S is 'A'
add A to all numbers of L[i..N].
else if ith letter of S is 'M'
multiply B to all numbers of L[i..N].
for all number in L[i..N], module them by C.
print L[i]
end
最佳答案
这个答案很长,但是恕我直言,我已经以一种相当容易理解的方式编写了它,并做了很多解释,所以请耐心等待一下。
假设O(N)
和A
都是整数,则可以在B
时间内解决此问题。否则,您可以在此时停止阅读。但是我认为有必要将算法分为几个不同的步骤,每个步骤都是O(N)
。因此总体上仍然是O(N)
。
问题的最困难部分可能是弄清楚如何使此步骤线性运行:
if ith letter of S is 'R'
reverse L[i...N]
L
数组有多长时间,因此我们只需维护3个变量
leftmost
,
rightmost
和
isReversed
。
leftmost
将保存L
数组的当前最左边的未使用索引,因此leftmost
初始化为1
,因为我们正在使用您的问题中所述的一个索引数组(术语“未使用”将在后面解释)。 rightmost
将保存L
数组的当前最右边的未使用索引,因此被初始化为N
的长度L
。 isReversed
用于指示阵列是否被反转。这被初始化为false
。 L
操作之后找出
reverse
数组原始元素的最终顺序。为了获得与反转相同的效果,甚至不需要反转阵列。这可以通过遍历输入字符串
S
一次,并找出所有反向操作后数组
L
的哪个元素应该在每个位置来完成。为简单起见,我们创建了一个新的整数数组
L'
,该数组将在应用所有反向操作后保留
L
的最终原始元素,并尝试填充
L'
。
i
和
S[i] == 'R'
的索引处,因此我们将
isReversed = true
设置为指示我们正在反转子数组
[i..N]
。当使用
isReversed == true
时,我们知道子数组
[i..N]
被反转了,因此
L'[i]
处的元素应该是最右边的未使用元素,其索引为
rightmost
。因此,我们通过
L'[i] = L[rightmost]
(
rightmost
)设置
1
和
递减
rightmost = rightmost - 1
。相反,如果
isReversed == false
我们没有反转子数组
[i..N]
,那么
L'[i]
处的元素应该是最左边的未使用元素,其索引为
leftmost
。因此,我们通过
L'[i] = L[leftmost]
(
leftmost
)设置
1
和
增量
leftmost = leftmost - 1
。随后的
reverse
将否定
isReversed
的值。
// set up new array L'
int Lprime[N+1];
int leftmost = 1;
int rightmost = N;
bool isReversed = false;
for (int i = 1; i <= N; i++) {
if (S[i] == 'R') {
// negate isReversed
isReversed = !isReversed;
}
if (isReversed) {
Lprime[i] = L[rightmost];
rightmost = rightmost - 1;
} else {
Lprime[i] = L[leftmost];
leftmost = leftmost + 1;
}
}
else if ith letter of S is 'A'
add A to all numbers of L[i..N].
else if ith letter of S is 'M'
multiply B to all numbers of L[i..N].
for all number in L[i..N], module them by C.
C
在子数组
[i..N]
上通过
i
执行模运算。但是基于我的有限理解,这是模运算,我们实际上不需要为每个
[i..N]
在子数组
i
上执行它。但不要相信我。我对数论的理解非常初级。
multiplicativeFactor
和
additiveConstant
。
multiplicativeFactor
用于保存我们需要乘以
L'[i]
的常量。最初是
1
。顾名思义,
additiveConstant
变量用于存储将
L'[i]
与
L'[i]
相乘后需要添加到
multiplicativeFactor
的任何常量。
additiveConstant
与
0
结合。
A = 3
,
B = 5
。假设
S
是字符串
"AMMAAM"
。这意味着以下内容(
注意:,我们暂时忽略
C
模数):
1
处,设置L'[1] = L'[1] + 3;
2
处,设置L'[2] = (L'[2] + 3) * 5;
3
处,设置L'[3] = ((L'[3] + 3) * 5) * 5;
4
处,设置L'[4] = (((L'[4] + 3) * 5) * 5) + 3;
5
处,设置L'[5] = ((((L'[5] + 3) * 5) * 5) + 3) + 3
6
处,设置L'[6] = (((((L'[6] + 3) * 5) * 5) + 3) + 3) * 5
'A'
和
'M'
的影响会“延续”(或级联)到
L'
的 future 元素中。让我们稍微表达一下这些操作:
L'[1] = L'[1] + 3
L'[2] = 5 * L'[2] + (3 * 5)
L'[3] = 5 * 5 * L'[3] + (3 * 5 * 5)
L'[4] = 5 * 5 * L'[4] + (3 * 5 * 5 + 3)
L'[5] = 5 * 5 * L'[5] + (3 * 5 * 5 + 3 + 3)
L'[6] = 5 * 5 * 5 * L'[6] + (3 * 5 * 5 + 3 + 3) * 5
L'[i]
的乘法因子始终是B
的幂。添加A
对这个乘法因子没有任何影响。乘法因子存储在我们上面描述的multiplicativeConstant
变量L'[i]
与一个附加的B
相乘时,就需要将所有常量(由添加A
引起)乘以B
,以获得要添加到L'[i]
的最终常量。这就是上述additiveConstant
变量的目的。 L'[i]
添加到additiveConstant
之前,应完成L'[i]
的乘法运算L'[i]
的最终值可以表示为
multiplicativeConstant * L'[i] + additiveConstant;
,并且算法的第二个主要部分如下所示:
int multiplicativeConstant = 1;
int additiveConstant = 0;
for (int i = 1; i <= N; i++) {
if (S[i] == 'A') {
additiveConstant += A;
} else if (S[i] == 'M') {
multiplicativeConstant *= B;
// need to multiply all the constants by B as well
additiveConstant *= B;
}
Lprime[i] = multiplicativeConstant * Lprime[i] + additiveConstant;
}
multiplicativeConstant
和additiveConstant
的整数溢出,以及中间计算。如果
L
是
int
数组,那么我们很幸运,因为我们可以对所有内容使用
long long
并避免溢出。否则,我们必须注意中间计算不会溢出。
modulo C
操作如何?实际上,它们可以将
L'[i]
中的每个值都保持在
[0..C-1]
范围内。基于我对数论的有限理解,我们可以像这样执行模运算以达到相同的效果:
int multiplicativeConstant = 1;
int additiveConstant = 0;
for (int i = 1; i <= N; i++) {
if (S[i] == 'A') {
additiveConstant = (additiveConstant + (A % C)) % C;
} else if (S[i] == 'M') {
multiplicativeConstant = (multiplicativeConstant * (B % C)) % C;
// need to multiply all the constants by B as well
additiveConstant = (additiveConstant * (B % C)) % C;
}
Lprime[i] = ((multiplicativeConstant * (Lprime[i] % C)) % C + additiveConstant) % C;
}
multiplicativeConstant
和
additiveConstant
变量的溢出问题(但不能防止中间计算和其他变量的溢出),并完善了我们的算法。我相信这是正确的,但是请您自己验证。我无法解释模块化算术知识,因为我只知道如何使用它,因此您将不得不自己查找它。附带一提,
A % C
和
B % C
部分可以完成一次,其结果存储在变量中。
// set up new array L'
int Lprime[N+1];
int leftmost = 1;
int rightmost = N;
bool isReversed = false;
for (int i = 1; i <= N; i++) {
if (S[i] == 'R') {
// negate isReversed
isReversed = !isReversed;
}
if (isReversed) {
Lprime[i] = L[rightmost];
rightmost = rightmost - 1;
} else {
Lprime[i] = L[leftmost];
leftmost = leftmost - 1;
}
}
int multiplicativeConstant = 1;
int additiveConstant = 0;
// factor out A % C and B % C
int aModC = A % C;
int bModC = B % C;
for (int i = 1; i <= N; i++) {
if (S[i] == 'A') {
additiveConstant = (additiveConstant + aModC) % C;
} else if (S[i] == 'M') {
multiplicativeConstant = (multiplicativeConstant * bModC) % C;
// need to multiply all the constants by B as well
additiveConstant = (additiveConstant * bModC) % C;
}
Lprime[i] = ((multiplicativeConstant * (Lprime[i] % C)) % C + additiveConstant) % C;
}
// print Lprime
O(N)
时间运行。
L
是
int
数组,则可以将
long long
用于计算中涉及的所有变量,应该没问题。
关于java - 如何将n个数字相加,相乘到数组中的给定范围,并以O(n)时间反转数组中的范围?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/21058575/
我看到以下宏 here . static const char LogTable256[256] = { #define LT(n) n, n, n, n, n, n, n, n, n, n, n,
这个问题不太可能帮助任何 future 的访问者;它只与一个小的地理区域、一个特定的时间点或一个非常狭窄的情况有关,这些情况并不普遍适用于互联网的全局受众。为了帮助使这个问题更广泛地适用,visit
所以我得到了这个算法我需要计算它的时间复杂度 这样的 for i=1 to n do k=i while (k<=n) do FLIP(A[k]) k
n 的 n 次方(即 n^n)是多项式吗? T(n) = 2T(n/2) + n^n 可以用master方法求解吗? 最佳答案 它不仅不是多项式,而且比阶乘还差。 O(n^n) 支配 O(n!)。同样
我正在研究一种算法,它可以在带有变音符号的字符(tilde、circumflex、caret、umlaut、caron)及其“简单”字符之间进行映射。 例如: ń ǹ ň ñ ṅ ņ ṇ
嗯..我从昨天开始学习APL。我正在观看 YouTube 视频,从基础开始学习各种符号,我正在使用 NARS2000。 我想要的是打印斐波那契数列。我知道有好几种代码,但是因为我没有研究过高深的东西,
已关闭。这个问题是 off-topic 。目前不接受答案。 想要改进这个问题吗? Update the question所以它是on-topic用于堆栈溢出。 已关闭12 年前。 Improve th
谁能帮我从 N * N * N → N 中找到一个双射数学函数,它接受三个参数 x、y 和 z 并返回数字 n? 我想知道函数 f 及其反函数 f',如果我有 n,我将能够通过应用 f'(n) 来
场景: 用户可以在字符串格式的方程式中输入任意数量的括号对。但是,我需要检查以确保所有括号 ( 或 ) 都有一个相邻的乘数符号 *。因此 3( 应该是 3*( 和 )3 应该是 )*3。 我需要将所有
在 Java 中,表达式: n+++n 似乎评估为等同于: n++ + n 尽管 +n 是一个有效的一元运算符,其优先级高于 n + n 中的算术 + 运算符。因此编译器似乎假设运算符不能是一元运算符
当我阅读 this 问题我记得有人曾经告诉我(很多年前),从汇编程序的角度来看,这两个操作非常不同: n = 0; n = n - n; 这是真的吗?如果是,为什么会这样? 编辑: 正如一些回复所指出
我正在尝试在reveal.js 中加载外部markdown 文件,该文件已编写为遵守数据分隔符语法: You can write your content as a separate file and
我试图弄清楚如何使用 Javascript 生成一个随机 11 个字符串,该字符串需要特定的字母/数字序列,以及位置。 ----------------------------------------
我最近偶然发现了一个资源,其中 2T(n/2) + n/log n 类型 的递归被 MM 宣布为无法解决。 直到今天,当另一种资源被证明是矛盾的(在某种意义上)时,我才接受它作为引理。 根据资源(下面
关闭。此题需要details or clarity 。目前不接受答案。 想要改进这个问题吗?通过 editing this post 添加详细信息并澄清问题. 已关闭 8 年前。 Improve th
我完成的一个代码遵循这个模式: for (i = 0; i < N; i++){ // O(N) //do some processing... } sort(array, array + N
有没有办法证明 f(n) + g(n) = theta(n^2) 还是不可能?假设 f(n) = theta(n^2) & g(n) = O(n^2) 我尝试了以下方法:f(n) = O(n^2) &
所以我目前正在尝试计算我拥有的一些数据的 Pearson R 和 p 值。这是通过以下代码完成的: import numpy as np from scipy.stats import pearson
ltree 列的默认排序为文本。示例:我的表 id、parentid 和 wbs 中有 3 列。 ltree 列 - wbs 将 1.1.12, 1.1.1, 1.1.2 存储在不同的行中。按 wbs
我的目标是编写一个程序来计算在 python 中表示数字所需的位数,如果我选择 number = -1 或任何负数,程序不会终止,这是我的代码: number = -1 cnt = 0 while(n
我是一名优秀的程序员,十分优秀!