链接：http://acm.hdu.edu.cn/showproblem.php?pid=5288

OO’s Sequence

5
1 2 3 4 5

23

题意：

本来的题意问  枚举所有i，j ，1<=i<=j<=n,  然后计算f（i,j）和是多少。

f(l,r)的值 是 输入的数组下标 l到r中有多少 数是无法被这个区间 任意一个数整除的。 

做法：

转换种思想就是 某个数num[i]，在多少个区间内 可以不被区间其他任何数整除。  答案加上区间个数。

所以 可以左右两边枚举过来。

以左边枚举过来为例：

把最近出现的数 记录下来，记录到 has数组。   如num[i]      记录成has[num[i]]=i     

然后把每个数的因子枚举，判断最近左边出现因子在哪。  然后那个位子+1 就是左端点了。

在同样处理出右端点， 左右端点知道就很容易算出num[i]在多少区间内符合要求 加到ans里。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <malloc.h>
#include <ctype.h>
#include <math.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <set>
using namespace std;

int num[100010];

int zuo[100010];

int you[100010];

int has[10010];
int Scan()
{
    int res = 0, ch, flag = 0;

    if((ch = getchar()) == '-')                //判断正负
        flag = 1;

    else if(ch >= '0' && ch <= '9')            //得到完整的数
        res = ch - '0';
    while((ch = getchar()) >= '0' && ch <= '9' )
        res = res * 10 + ch - '0';

    return flag ? -res : res;
}

vector<int>my[10010];


int main()
{
    int n;

    for(int i=1;i<=10000;i++)
    {
        for(int j=1;j<=i;j++)
        {
            if(i%j==0)
            {
                my[i].push_back(j); 
            } 
        } 
        //printf("%d\n",my[i].size());
    }


    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            //scanf("%d",&num[i]);
            //num[i]=min(10000,i);
            num[i]=Scan();
        }

        memset(zuo,-1,sizeof zuo);
        memset(you,-1,sizeof you);
        /*
        memset(has,0,sizeof has);
        
        for(int i=1;i<=n;i++)
        {
            if(has[num[i]]!=0) 
                zuo[i]=has[num[i]]+1;//左边最近被整除 
            has[num[i]]=i;
        }
        memset(has,0,sizeof has);
        for(int i=n;i>=1;i--)
        {
            if(has[num[i]]!=0) 
                you[i]=has[num[i]]-1;//左边最近被整除 
            has[num[i]]=i;
        }
        */
        memset(has,0,sizeof has);
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<my[num[i]].size();j++)
            {
                int tt=my[num[i]][j];
                if(has[tt])
                {
                    if(num[i]%tt==0)
                    {
                        if(zuo[i]!=-1)
                            zuo[i]=max(zuo[i],has[tt]+1);
                        else
                            zuo[i]=has[tt]+1;
                    }
                }
            }
            has[num[i]]=i; 
        }

        memset(has,0,sizeof has);
        for(int i=n;i>=1;i--)
        {
            for(int j=0;j<my[num[i]].size();j++)
            {
                int tt=my[num[i]][j];
                if(has[tt])
                {
                    if(num[i]%tt==0)
                    {
                        if(you[i]!=-1)
                            you[i]=min(you[i],has[tt]-1);
                        else
                            you[i]=has[tt]-1;
                    }
                }
            }
            has[num[i]]=i; 
        }

        for(int i=1;i<=n;i++)
        {
            if(zuo[i]==-1)
                zuo[i]=1;

            if(you[i]==-1)
                you[i]=n;
            //printf("zz%d yy%d\n",zuo[i],you[i]);
        }

    //    puts("-----------");
        __int64 ans=0;
        for(int i=1;i<=n;i++)
        {
            __int64 l,r;
            l=(__int64)(i-zuo[i]+1);
            r=(__int64)(you[i]-i+1);

            //printf("zz%d yy%d\n",l,r);
            ans=(ans+l*r)%1000000007;
        }
        printf("%I64d\n",ans);
    } 
    return 0;
}

hdu 5288 OO’s Sequence 分解因子

原文：http://blog.csdn.net/u013532224/article/details/46992475