Problem I

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <cmath>
#include <vector>
#include <set>
#include <stack>
#include <algorithm>
//#include "myAlgorithm.h"

#define MAX 100005
#define INF (1e8 + 5)
#define eps 1e-30
#define Rep(s, e) for( int i = s; i <= e; i++)
#define Cep(e, s) for( int i = e; i >= s; i --)
using namespace std;
/*
因为串的大小顺序都是小到大, 所以串的顺序和原串的顺序一样~~~, 这样就简单了
dp[i]代表从a[1] - a[i]的最长串,   则dp[i] = max(dp[j] + 1);   当gcd(a[j], a[i]) > 1 && j < i时,
*/
int n, a[MAX];
int gcd(int a, int b){/// a >= b
    a = a % b; // a < b
    return  (!a )? b : gcd(b, a);
}
void makeDP(){
    int dp[MAX];
    Rep(1, n)dp[i] = 1;
    Rep(2, n){
         for(int j = i - 1; j > 0; j--){
             int aa = a[i], bb = a[j];
             if(aa < bb)swap(aa, bb);
             if(gcd(aa, bb) > 1){
                dp[i] = max(dp[i] , dp[j] + 1);
            }
         }
    }
    cout<<dp[n]<<endl;
}
///---------------------TLE--------以计算最长递X序列的方法, 复杂度为O(n * (n * gcd)),没能爽A-----

///----------------------AC-----预处理了因子, dp状态由因子的关系转移, 而不是直接gcd-----
/*学习了下大神们的博客~~
     首先预处理所有a[i]的因子,存于(vector<int>)factor[i];    O(n * sqrt(n));
    dp[f]表示从a[1]到含有因子f的数a[i]的最大长度 ：
    状态转移要经过两步：,                                                         maxSubLen(a[1] to a[i]) = max(dp[ff] + 1)   ///获取最大值
                                                                                                      dp[ff]  = maxSubLen(a[1] to a[i])  , ff 存在于factor[i];///更新因子最大值
     之前在(vector<int>)factor[i]存储了a[i]的所有因子 ,状态转移的ff就好办了;

比划一下就知道这个状态转移的意思了 , T T~~~   DP若爆了~~
总时间复杂度:   O(n * sqrt(n))
 */
vector<vector<int> >factor;
int ans;
void getDiv(int num, int pos){///分解因子
    if(num == 1){
        factor[pos].push_back(1);///比较特殊, len * len = num, 但是不能pop_back， 里面没值
        return ;
    }
    int len  = sqrt(num);
    Rep(2, len){
        if(num % i == 0){
            //cout<<num<<" i"<<i<<endl;
            int temp = num / i;
            factor[pos].push_back(i);
            factor[pos].push_back(temp);
        }
    }
    if(len * len == num){
        factor[pos].pop_back();
    }
    factor[pos].push_back(num);///自身
}
void runDP(){
    int dp[MAX];
    ans = -INF;
    Rep(0, a[n]){
        dp[i] = 0;
    }
    Rep(1, n){
        int size = factor[i].size();
        int maxF = -INF;
        for( int j = 0; j < size; j++){
            int ff = factor[i][j];
            dp[ff]++;
            maxF = max(maxF, dp[ff]);///maxSubLen(a[1] to a[i]) = max(dp[ff] + 1)   && ff  存在于factor[i],
        }
        for(int j = 0; j < size; j++){
            int ff = factor[i][j];
            dp[ff]  = maxF;/// dp[ff]  = maxSubLen(a[1] to a[i])  &&  ff 存在于factor[i]
        }
        ans = max(maxF, ans);
    }
    cout<<ans<<endl;
}
int main()
 {
    //freopen("in.tx0t", "w", stdout);
    while(cin>>n){
        factor.assign(n + 2, vector<int>() );
        Rep(1, n){
            cin>>a[i];
            //a[i] = i;
            getDiv(a[i], i);
        }///end input
        runDP();
        factor.clear();
    }
    return 0;
}
/*

*/