1 #include<cstdio>
  2 #include<cctype>
  3 #include<cstdlib>
  4 #include<algorithm>
  5 typedef signed long long int int64;
  6 inline unsigned getint() {
  7     register char ch;
  8     while(!isdigit(ch=getchar()));
  9     register unsigned x=ch^'0';
 10     while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
 11     return x;
 12 }
 13 inline int64 min(const int64 &a,const int64 &b) {
 14     return a<b?a:b;
 15 }
 16 const int64 inf=0x7ffffffffffffff;
 17 const int N=200001;
 18 int n;
 19 class FenwickTree {
 20     private:
 21         int64 val[N];
 22         int lowbit(const int &x) const {
 23             return x&-x;
 24         }
 25     public:
 26         FenwickTree() {
 27             std::fill(&val[0],&val[N],inf);
 28         }
 29         void modify(int p,const int64 &x) {
 30             while(p<=n) {
 31                 if(x<val[p]) {
 32                     val[p]=x;
 33                 } else {
 34                     return;
 35                 }
 36                 p+=lowbit(p);
 37             }
 38         }
 39         int64 query(int p) const {
 40             int64 ret=inf;
 41             while(p) {
 42                 ret=min(ret,val[p]);
 43                 p-=lowbit(p);
 44             }
 45             return ret;
 46         }
 47 };
 48 FenwickTree ta;
 49 class RevFenwickTree {
 50     private:
 51         int64 val[N];
 52         int lowbit(const int &x) const {
 53             return x&-x;
 54         }
 55     public:
 56         RevFenwickTree() {
 57             std::fill(&val[0],&val[N],inf);
 58         }
 59         void modify(int p,const int64 &x) {
 60             while(p) {
 61                 if(x<val[p]) {
 62                     val[p]=x;
 63                 } else {
 64                     return;
 65                 }
 66                 p-=lowbit(p);
 67             }
 68         }
 69         int64 query(int p) const {
 70             int64 ret=inf;
 71             while(p<=n) {
 72                 ret=min(ret,val[p]);
 73                 p+=lowbit(p);
 74             }
 75             return ret;
 76         }
 77 };
 78 RevFenwickTree tb;
 79 int64 f[N];
 80 inline void modify(const int &p,const int64 x) {
 81     if(x<f[p]) {
 82         f[p]=x;
 83         ta.modify(p,x-p);
 84         tb.modify(p,x+p);
 85     }
 86 }
 87 int main() {
 88     n=getint();
 89     int q=getint(),a=getint(),b=getint();
 90     std::fill(&f[0],&f[N],inf);
 91     modify(a,0);
 92     int64 sum=0;
 93     while(q--) {
 94         a=b;
 95         b=getint();
 96         sum+=abs(a-b);
 97         int64 t1=ta.query(b)+b,t2=tb.query(b)-b;
 98         modify(a,min(t1,t2)-abs(a-b));
 99     }
100     int64 tmp=inf;
101     for(register int i=1;i<=n;i++) {
102         tmp=min(tmp,f[i]);
103     }
104     printf("%lld\n",tmp+sum);
105     return 0;
106 }

 1 #include<cstdio>
 2 #include<cctype>
 3 #include<cstring>
 4 #include<cstdlib>
 5 inline unsigned getint() {
 6     register char ch;
 7     while(!isdigit(ch=getchar()));
 8     register unsigned x=ch^'0';
 9     while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
10     return x;
11 }
12 inline unsigned min(const unsigned &a,const unsigned &b) {
13     return a<b?a:b;
14 }
15 const unsigned N=200000;
16 unsigned long long f[2][N];
17 unsigned a[2];
18 int main() {
19     unsigned n=getint(),q=getint();
20     memset(f[0],0xff,n<<3);
21     a[0]=getint()-1,f[0][getint()-1]=0;
22     for(register unsigned i=1;i<=q;i++) {
23         a[i&1]=getint()-1;
24         memset(f[i&1],0xff,n<<3);
25         for(register unsigned j=0;j<n;j++) {
26             if(!~f[~i&1][j]) continue;
27             f[i&1][j]=min(f[i&1][j],f[~i&1][j]+abs(a[i&1]-a[~i&1]));
28             f[i&1][a[~i&1]]=min(f[i&1][a[~i&1]],f[~i&1][j]+abs(a[i&1]-j));
29         }
30     }
31     unsigned long long ans=~0;
32     for(register unsigned i=0;i<n;i++) {
33         ans=min(ans,f[q&1][i]);
34     }
35     printf("%llu\n",ans);
36     return 0;
37 }

View Code