如何解决每个大小为k的窗口中的第一个负整数，具有辅助空间O1和On时间复杂度
给出一个数组和一个正整数k，为每个大小为k的窗口（连续子数组）找到第一个负整数。如果窗口不包含负整数，则为该窗口打印0。
package com.slidingwindow;
public class demo2 {
public static void maximum(int arr[],int k) {
int index = -1;
boolean flag = false;
int i = 0,j = 0,sum = 0;
while (j < arr.length) {
if(arr[j]<0 && !flag) {
index =j;
flag = true;
System.out.println(arr[index]);
}
if (j - i + 1 < k) {
j++;
} else if (j - i + 1 == k) {
if(!flag) {
System.out.println("0");
i++;
j++;
}else {
//slide window by incrementing i and j
i++;
j++;
flag = false;a
}
}
}
}
public static void main(String[] args) {
int arr[] = { -2,5,1,8,-2,9,-1 };
int k = 2;
maximum(arr,k);
}
}
预期输出
-2
0
0
-2
-2
-1
实际
-2
0
0
-2
0
-1
解决方法
我试图了解您的逻辑，但我不太明白。这是我想出的，几乎是从零开始的：
class demo2 {
public static void maximum (int arr[],int k){
for (int j = 0; j < arr.length - k + 1; j++) {
boolean found = false;
for (int x = j; x < j + k; x++) {
if (arr[x] < 0) {
System.out.println(arr[x]);
found = true;
break;
}
}
if (!found)
System.out.println(0);
}
}
public static void main(String[] args) {
int arr[] = { -2,5,1,8,-2,9,-1 };
int k = 2;
maximum(arr,k);
}
}
结果：
-2
0
0
-2
-2
-1
我认识到，如果数组长度和窗口大小都很大，那么可能会有更有效的方法来解决这一问题。但是您的问题并没有说明是这种情况。在这个地方，您需要确定要花费时间来优化，而不是简单而显而易见的解决方案。
,它可以用实际的线性复杂度 O（n）来实现（与多项式复杂度 O（n * k）的朴素实现相反。 strong>）：
public static void maximum (int arr[],int k) {
int index = -1;
for (int i = arr.length - 1; i >= 0; i--) {
if (index >= i + k) {
index = -1;
}
if (arr[i] < 0) {
index = i;
}
arr[i] = index >= 0 ? arr[index] : 0;
}
for(int i = 0; i <= arr.length - k; i++) {
System.out.println(arr[i]);
}
}
更新：甚至更好，而无需写入arr数组：
public static void maximum (int arr[],int k) {
int index = -1;
for (int i = 0; i < arr.length - k + 1; i++) {
if(index < i) {
// Find the index of the next negative number
do {
index++;
} while (index < arr.length && arr[index] >= 0);
}
// If the next negative number is within the window print it,// otherwise print "0"
System.out.println(index < i + k ? arr[index] : 0);
}
}
就（内部）循环的迭代次数（最坏的情况，即表中根本没有负数）与朴素算法O（n * k）进行比较：
| naive | dynamic |
| O((n-m+1)*m) | O(n) |
--------------------------------------
n=7,m=2 | 12 | 7 |
n=10,m=2 | 18 | 10 |
n=100,m=10 | 910 | 100 |
n=100,m=50 | 2550 | 100 |
我有一个 c++ 解决方案，我也提交了关于 gfgs 练习问题的代码，它被接受了。时间复杂度为O(n)，辅助空间复杂度为O(K)
vector<int> firstNegative(vector<int> arr,int lenn,int k)
{
vector <int> ans;
int start = 0,end = 0;
queue <int> index;
while(start <= lenn-k)
{
if(arr[end] < 0)
index.push(end);
if(k == (end-start+1))
{
if(index.empty())
ans.push_back(0);
else
{
if(index.front()>=start && index.front()<=end)
ans.push_back(arr[index.front()]);
else
{
index.pop();
continue;
}
}
start++;
}
end++;
}
return ans;
}
Deque<Long> queue = new LinkedList<>();
int C=N-K+1;
long[] output = new long[C];
int c = -1;
int startWindow = 0;
int endWindow =K;
boolean firstFlag=true;
while (true) {
for(int j=startWindow;j<endWindow;j++){
if(A[j] < 0 && firstFlag){
// queue.add(A[j]);
if(c<C-1){
output[++c]=A[j];
}
firstFlag=false;
break;
}
if(j>=N-1) {
break;
}
}
if(firstFlag){
if(c<C-1){
output[++c]=0;
}
// queue.add((long)0);
}
if(endWindow>=N){
break;
}
firstFlag=true;
startWindow=startWindow+K-1;
endWindow=startWindow+K;
}
// while(!queue.isEmpty())
// output[++c] = queue.remove();
return output;
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
