Problem:
Score : 900 points

Problem Statement

There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.

You have two pieces, initially placed on square A and B, respectively.
You will be asked to process Q queries of the following kind, in the order received:

Given an integer x_i, move one of the two pieces of your choice to square x_i.

Here, it takes you one second to move a piece one square.
That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.

Your objective is to process all the queries in the shortest possible time.

You may only move the pieces in response to queries, and you may not move both pieces at the same time.
Also, it is not allowed to rearrange the order in which queries are given.
It is, however, allowed to have both pieces in the same square at the same time.

Constraints

1 ≤ N, Q ≤ 200,000

1 ≤ A, B ≤ N

1 ≤ x_i ≤ N

Input

Input is given from Standard Input in the following format:

N Q A B
x_1 x_2 ... x_Q

Output

Let the shortest possible time to process all the queries be X seconds. Print X.

Sample Input 1

8 3 1 8
3 5 1

Sample Output 1

7

All the queries can be processed in seven seconds, by:

moving the piece at square 1 to 3

moving the piece at square 8 to 5

moving the piece at square 3 to 1

Sample Input 2

9 2 1 9
5 1

Sample Output 2

4

The piece at square 9 should be moved first.

Sample Input 3

9 2 1 9
5 9

Sample Output 3

4

The piece at square 1 should be moved first.

Sample Input 4

11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7

Sample Output 4

21

Solution in Fortran (gfortran v4.8.4) (judge verdict: Wrong Answer)

module mod_segment_tree
  implicit none
  integer(8), parameter :: inf = 100000000000_8
  type t_segment_tree
    private
    integer(8) :: deflt = inf
    integer :: n, p
    integer(8), pointer :: arr(:) => null()
  contains
    procedure :: init => init_segtree
    procedure :: release => release_segtree
    procedure :: update => update
    procedure :: query => query
    procedure :: default => set_default
    procedure :: change => change_default
  end type
contains
  integer function op(x,y)
    integer(8), intent(in) :: x, y
    op = min(x,y)
  end
  subroutine init_segtree(this,n)
    class(t_segment_tree), intent(inout) :: this
    integer, intent(in) :: n
    integer :: p
    p = 1
    do while (p < n)
      p = 2*p
    end do
    this%n = n
    this%p = p
    allocate(this%arr(2*p-1))
    this%arr = this%deflt
  end
  subroutine release_segtree(this)
    class(t_segment_tree), intent(inout) :: this
    if (associated(this%arr)) deallocate(this%arr)
  end
  subroutine set_default(this,i)
    class(t_segment_tree), intent(inout) :: this
    integer, intent(in) :: i
    integer :: x
    x = i+this%p-1
    this%arr(x) = this%deflt
    do while (x > 1)
      x = x/2
      this%arr(x) = op(this%arr(2*x),this%arr(2*x+1))
    end do
  end
  subroutine change_default(this,deflt)
    class(t_segment_tree), intent(inout) :: this
    integer(8), intent(in) :: deflt
    this%deflt = deflt
  end
  subroutine update(this,i,v)
    class(t_segment_tree), intent(inout) :: this
    integer, intent(in) :: i
    integer(8), intent(in) :: v
    integer :: x
    x = i+this%p-1
    this%arr(x) = v
    do while (x > 1)
      x = x/2
      this%arr(x) = op(this%arr(2*x),this%arr(2*x+1))
    end do
  end
  integer(8) function query(this,a,b)
    class(t_segment_tree), intent(inout) :: this
    integer, intent(in) :: a, b
    integer :: l, r
    query = this%deflt
    l = a+this%p-1
    r = b+this%p-1
    do while (l <= r)
      if (mod(l,2) == 1) then
        query = op(query,this%arr(l))
        l = l+1
      end if
      if (mod(r,2) == 0) then
        query = op(query,this%arr(r))
        r = r-1
      end if
      l = l/2
      r = r/2
    end do
  end
end module mod_segment_tree
program many_moves
  use mod_segment_tree
  implicit none
  type(t_segment_tree) :: plus, minus
  integer :: n, q, a, b, x(200000) = 0, i, j
  integer(8) :: ans = 1000000_8*inf, offset = 0_8, tmp, v1, v2
  read(*,*) n, q, a, b
  read(*,*) x(1:q)
  call plus%init(n)
  call minus%init(n)
  call set(a,0_8)
  do i = 1, q
    tmp = int(abs(x(i)-b),8)
    v1 = rmq(x(i))
    v2 = get(b)+tmp
    call set(b,min(v1,v2)-tmp)
    offset = offset+tmp
    b = x(i)
  end do
  do i = 1, n
    ans = min(ans,get(i))
  end do
  write(*,'(i0)') ans
contains
  subroutine set(i,v)
    integer, intent(in) :: i
    integer(8), intent(in) :: v
    call plus%update(i,v+int(i,8))
    call minus%update(i,v-int(i,8))
  end
  integer(8) function get(i)
    integer, intent(in) :: i
    get = plus%query(i,i)-int(i,8)+offset
  end
  integer(8) function rmq(i)
    integer, intent(in) :: i
    rmq = min(minus%query(1,i-1)+int(i,8),plus%query(i,n)-int(i,8))
  end
end program many_moves