HDU6098 Inversion

Inversion

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 45    Accepted Submission(s): 28

Problem Description

Give an array A, the index starts from 1.
Now we want to know Bi=maxi∤jAj , i≥2 .

 

Input

The first line of the input gives the number of test cases T; T test cases follow.
Each case begins with one line with one integer n : the size of array A.
Next one line contains n integers, separated by space, ith number is Ai .

Limits
T≤20
2≤n≤100000
1≤Ai≤1000000000
∑n≤700000

 

Output

For each test case output one line contains n-1 integers, separated by space, ith number is Bi+1 .

 

Sample Input

  
  

   
   2
4
1 2 3 4
4
1 4 2 3
  
  

 

Sample Output

  
  

   
   3 4 3
2 4 4
  
  

 

题目大意：给你一个数列A下标为j然后i从2开始让你求j%i!=0的A数列中的最大值为Bi，i从2开始到n。

解题思路：我的想法是分区间求最大值将j%i==0的数除去然后这个数列就被分为了好几个区间让后用RMQ求区间的最大值，要注意数组边缘的值。

AC代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAXN 100010
int n,m;
int a[MAXN];
int b[MAXN];
int f[20][MAXN<<1];

void ST()
{
    for(int i=1; i<=n; i++)
    {
        f[0][i]=a[i];
    }
    for(int j=1; j<20; j++)
    {
        for(int i=1; i<=n; i++)
        {
            f[j][i]=max(f[j-1][i],f[j-1][i+(1<<(j-1))]);
        }
    }
}
void init()
{
    memset(f,0,sizeof(f));
    memset(a,0,sizeof(a));
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        init();
        memset(b,0,sizeof(b));
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        ST();
        for(int i=2; i<=n; i++)
        {
            for(int j=0; j<=n/2; j++)
            {
                if(i*j>n)
                {
                    break;
                }
                else
                {
                    if(i*j<n&&(j+1)*i>n)
                    {
                        int l=j*i+1;
                        int r=n;
                        int k=(int)(log((double)(r-l+1))/log(2.0));
                        b[i]=max(b[i],max(f[k][l],f[k][r-(1<<k)+1]));
                    }
                    else
                    {
                        int l=j*i+1;
                        int r=(j+1)*i-1;
                        int k=(int)(log((double)(r-l+1))/log(2.0));
                        b[i]=max(b[i],max(f[k][l],f[k][r-(1<<k)+1]));
                    }

                }
            }
            //printf("%d\n",b[i]);
        }
        for(int i=2;i<n;i++)
		{
			printf("%d ",b[i]);
		}
		printf("%d\n",b[n]);
    }
    return 0;
}

还有一种思路为把A数列存到一个结构体数组里面，结构体数组里面分别存的是A数列的值以及A数列的下标。然后给A数列排序，找的第一个下标不能被j整除的数就是Bi的值。

这个应该为正解，比较好想，上一个虽然也能过但感觉就不怎么好了。写上面的思路是因为昨天刚刚看了RMQ算法今天就能用上感觉没有白学。

代码：

#include<cstdio>
#include<algorithm>
using namespace std;
struct ss
{
    int i;
    long long num;
};
bool cmp(ss a,ss b)
{
    return a.num>b.num;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        ss a[100000+5];
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            a[i].i=i;
            scanf("%lld",&a[i].num);
        }
        sort(a+1,a+n+1,cmp);
        for(int j=2;j<=n;j++)
        {
            for(int k=1;k<=n;k++)
            {
                if(a[k].i%j!=0)
                {
                    printf("%lld%c",a[k].num,j==n?'\n':' ');
                    break;
                }
            }
        }
    }
    return 0;
}