提交一个能AC的代码

                       #include<bits/stdc++.h>
   #define ll long long
                 #define void inline void
                           #define g getchar()
                         #define pc(a) putchar(a)
                                    using 
   namespace 
                                  std
                     ;
                                const 
      ll 
                          N
                              =
                          1e3
                 +
                          7
                                        ;
                               ll 
                                fx
                      [
                      N
                            ]
             ,
                     fy
                 [
                              N
                              ]
                                 ,
                              sx
                                             [
               N
               ]
                       ,
          sy
                       [
                                       N
           ]
                               ,
                         n
               ,
    m
                                       ,
              f
           [
                         N
                              ]
              [
          N
                          ]
                                                [
                             2
                               ]
      ;
                           inline 
              ll 
                           rd
                             (
                            )
     {
                 ll 
                                         x
           =
                               0
         ,
                                            s
                                =
                                      1
                         ;
           char 
           c
                 =
                 g
                        ;
   while
                           (
                                  c
                              >
                                          '9'
                                               ||
              c
         <
                                     '0'
                 )
                      {
                                           if
                      (
                             c
    ==
                 '-'
                                      )
                        s
                              =
                              -1
                                     ;
                                     c
                 =
                                 g
                                 ;
                       }
                                while
                          (
                    c
                                         <=
            '9'
                         &&
               c
                                >=
                   '0'
                   )
   {
                                            x
                    =
                 x
              *
                           10
                                        +
               c
                 -
                                  '0'
                                   ;
               c
                  =
                                          g
                  ;
                            }
                        return 
              x
                        ;
                                   }
      void 
                                      qp
                        (
                      ll
                    u
                                   )
                         {
                            if
                                          (
                            u
                          <
                                0
        )
                                     {
                         pc
                    (
                                   '-'
                           )
                                            ;
                             u
            =
                   -u
                             ;
                    }
               if
                                      (
                         u
                                  /
                                          10
                     ==
                                0
                   )
                                           {
                 pc
                                  (
             u
                                            +
                     '0'
                )
      ;
                          return
                              ;
             }
              qp
                                    (
                   u
                       /
                                   10
                                   )
             ;
                      pc
                        (
                           u
                  %
                     10
           +
        '0'
         )
                                    ;
                              }
            int 
                                     main
               (
                   )
                 {
                      memset
                      (
           f
            ,
                          0x7f
                         ,
                                       sizeof
                              f
                         )
                                        ;
       n
                             =
                                 rd
               (
          )
                                    ;
                                  m
                        =
                        rd
                                         (
                          )
                ;
                                n
                    ++
                     ;
                                     m
                             ++
                ;
        f
               [
                             2
                  ]
                          [
                                 1
          ]
                         [
               0
                     ]
                               =
                   0
                         ;
                                     for
                                      (
                         ll
                            i
                    =
                                             2
                                      ;
                       i
                             <=
                  n
                                  ;
                                 i
                               ++
                               )
      fx
                   [
               i
           ]
                           =
               rd
          (
               )
                                     ,
        fy
                  [
       i
                         ]
                       =
                                rd
                             (
         )
                                      ;
                                for
                          (
                   ll
    i
          =
                              2
                           ;
               i
             <=
        m
                                          ;
          i
                                   ++
                              )
                                sx
            [
                   i
                  ]
                  =
        rd
                     (
           )
                               ,
           sy
             [
                          i
                       ]
                            =
                        rd
               (
                    )
                        ;
           for
               (
                                          int
                           i
                               =
            3
                     ;
                      i
                                       <=
                                 n
             ;
                                    i
               ++
                           )
                         f
                [
                                     i
             ]
                              [
                   1
                           ]
      [
                                         0
                       ]
                                  =
                           f
                              [
                      i
                  -
                             1
                                     ]
                     [
                    1
                                             ]
                         [
                                       0
                                      ]
                             +
                            (
                         fx
                         [
                         i
 ]
                         -
                               fx
                               [
                             i
              -
                          1
                                ]
             )
             *
                       (
                        fx
          [
                   i
                         ]
            -
                   fx
                                          [
                                i
                            -
                           1
              ]
                                           )
                               +
     (
                                  fy
                               [
                i
                                   ]
              -
                   fy
                    [
  i
                                    -
                                1
                ]
                                         )
                            *
                         (
                       fy
                            [
              i
          ]
                                 -
                            fy
                              [
                               i
                               -
           1
                          ]
      )
                      ;
     for
                            (
         ll
           i
                           =
                                2
                                 ;
                                i
                         <=
                                  n
 ;
                       i
                    ++
                           )
      for
             (
                                      ll
                j
                                   =
    2
                           ;
                                      j
                   <=
                                 m
                           ;
                              j
              ++
                )
                             f
            [
                                       i
       ]
                                         [
                  j
                      ]
             [
                                0
     ]
                             =
                                 min
                                             (
                                    f
                                            [
                     i
              -
                           1
                                   ]
                             [
                 j
                 ]
         [
                          0
                                   ]
   +
                                   (
        fx
                               [
                            i
                ]
                                          -
                     fx
                    [
                        i
                     -
                                     1
                  ]
                       )
              *
                        (
                              fx
                     [
                                  i
                             ]
       -
                         fx
                               [
                  i
                              -
                         1
                 ]
                               )
                             +
     (
                     fy
                [
                   i
                                ]
                               -
                         fy
                  [
                                 i
                            -
                                       1
                       ]
                      )
                    *
                        (
                                     fy
                                    [
                         i
         ]
               -
                              fy
              [
                                i
                             -
                                       1
                           ]
                                 )
                               ,
                   f
                                       [
                   i
                     -
                      1
               ]
 [
                                       j
                    ]
                       [
                      1
                               ]
                     +
                         (
                                          fx
        [
                       i
                           ]
                -
                   sx
                                 [
                          j
         ]
                           )
                                      *
                            (
                          fx
                           [
                           i
                                            ]
                       -
                          sx
                             [
                          j
                                 ]
  )
             +
                               (
                        fy
                       [
                                           i
                               ]
               -
                      sy
                            [
                          j
            ]
                                )
                        *
                      (
                  fy
               [
                                          i
                        ]
                                        -
            sy
                                    [
                      j
                          ]
           )
                      )
                                ,
                                f
                                  [
                     i
                            ]
            [
       j
                            ]
        [
                                    1
                         ]
                                =
                  min
                               (
                                f
                [
                                          i
                 ]
                          [
                         j
              -
                        1
           ]
                                          [
                                           0
               ]
                                  +
                                      (
                 sx
                  [
                                j
                        ]-
                    fx
                                            [
                                     i
                      ]
       )
                       *
                           (
                             sx
                                       [
                             j
          ]
          -
   fx
     [
                                 i
                                    ]
             )
                                      +
           (
                               sy
                        [
                                   j
                                   ]
                                      -
                                    fy
                           [
                         i
                ]
                         )
               *
                   (
                   sy
                        [
                         j
                             ]
                         -
                                           fy
                                           [
       i
         ]
                                    )
       ,
                                    f
            [
                                 i
                           ]
                       [
                                  j
                               -
                  1
                            ]
                     [
                                 1
                                         ]
                           +
                             (
                                  sx
                                       [
                        j
                                           ]
                  -
                                           sx
                               [
                                     j
                       -
                                1
                       ]
                            )
                   *
                           (
                                  sx
                         [
                               j
                                  ]
            -
                                       sx
                 [
                     j
                                     -
                             1
      ]
                                      )
                +
                                   (
                              sy
          [
                     j
                                          ]
                                -
                  sy
         [
                       j
                                 -
                       1
     ]
                                          )
                             *
                 (
               sy
                                   [
                                          j
                    ]
                                             -
             sy
                   [
                       j
                                             -
   1
                                        ]
     )
                             )
                              ;
                        qp
        (
                      f
                                           [
                                        n
                               ]
                                         [
                                      m
                         ]
                                     [
                                0
                             ]
                  )
                                       ;
                                    return 
                   0
                       ;
               }