Imperfect GPS

题目描述

Lots of runners use personal Global Positioning System (GPS) receivers to track how many miles they run. No GPS is perfect,
though: it only records its position periodically rather than continuously, so it can miss parts of the true running path. For this problem we’ll consider a GPS that works in the following way when tracking a run:
• At the beginning of the run, the GPS first records the runner’s starting position at time 0.
• It then records the position every t units of time.
• It always records the position at the end of the run, even if the total running time is not a multiple of t.
The GPS assumes that the runner goes in a straight line between each consecutive pair of recorded positions. Because of this, a GPS can underestimate the total distance run.
For example, suppose someone runs in straight lines and at constant speed between the positions on the left side of Table 1. The time they reach each position is shown next to the position. They stopped running at time 11. If the GPS records a position every 2 units of time, its readings would be the records on the right side of Table 1.

The total distance run is approximately 14.313708 units, while the GPS measures the distance as approximately 11.650281 units. The difference between the actual and GPS distance is approximately 2.663427 units, or approximately 18.607525% of the total run distance.
Given a sequence of positions and times for a running path, as well as the GPS recording time interval t, calculate the percentage of the total run distance that is lost by the GPS. Your computations should assume that the runner goes at a constant speed in a straight line between consecutive positions.

 

输入

The input consists of a single test case. The first line contains two integers n (2 ≤ n ≤ 100) and t(1 ≤ t ≤ 100), where n is the total number of positions on the running path, and t is the recording time interval of the GPS (in seconds).
The next n lines contain three integers per line. The i-th line has three integers xi, yi (−106 ≤ xi, yi ≤106), and ti (0 ≤ ti ≤ 106), giving the coordinates of the i-th position on the running path and the time (in seconds) that position is reached. The values of ti’s are strictly increasing. The first and last positions are the start and end of the run. Thus, t1 is always zero.
It is guaranteed that the total run distance is greater than zero.

 

输出

Output the percentage of the actual run distance that is lost by the GPS. The answer is considered correct if it is within 10−5 of the correct answer.

 

样例输入

6 2
0 0 0
0 3 3
-2 5 5
0 7 7
2 5 9
0 3 11

样例输出

18.60752550117103

 

题意：

给你一些时间段，在这些时间段内，走的路程是直线，并且速度恒定，然后有一个周期，让你从起始开始，每经过一个周期就取一个点，一直取到结束，就算最后一个点不满一个周期，也要取。并且在新组成的这些时间段内，也是匀速直线运动。求二者差占原来路程的百分比。将速度分解，求出水平的速度和垂直的速度，这样就可以直接计算经过t时间之后x，y的坐标，然后模拟一遍就好了。

AC代码

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<string>
#include<map>
#include<cmath>
#define INF 0x3f3f3f3f
#define rep(i,a,n) for(int i=a;i<n;i++)
#define per(i,a,n) for(int i=n-1;i>=a;i--)
#define fori(x) for(int i=0;i<x;i++)
#define forj(x) for(int j=0;j<x;j++)
#define memset(x,y) memset(x,y,sizeof(x))
#define memcpy(x,y) memcpy(x,y,sizeof(y))
#define sca(x) scanf("%d", &x)
#define scas(x) scanf("%s",x)
#define sca2(x,y) scanf("%d%d",&x,&y)
#define sca3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define scl(x) scanf("%lld",&x)
#define scl2(x,y) scanf("%lld%lld",&x,&y)
#define scl3(x,y,z) scanf("%lld%lld%lld",&x,&y,&z)
#define pri(x) printf("%d\n",x)
#define pri2(x,y) printf("%d %d\n",x,y)
#define pris(x) printf("%s\n",x)
#define prl(x) printf("%lld\n",x)
//#include <bits/stdc++.h>

typedef long long ll;
const int maxn=1e6+7;
const int mod=1e9+7;
const double eps=1e-8;
// const double pi = acos(-1);

using namespace std;
double t[maxn];
double sx[maxn],sy[maxn];
double gx[maxn],gy[maxn];
double vx[maxn],vy[maxn];
double s_res = 0;
double g_res = 0;
int main()
{
    int n;
    double T;
    scanf("%d%lf",&n,&T);
    rep(i,0,n)
    {
      scanf("%lf%lf%lf",&sx[i],&sy[i],&t[i]);
      if(i == 0)
        continue;
      vx[i] = 1.0*(sx[i] - sx[i-1])/(t[i] - t[i-1]);
      vy[i] = 1.0*(sy[i] - sy[i-1])/(t[i] - t[i-1]);
      s_res += sqrt((sx[i]-sx[i-1])*(sx[i]-sx[i-1]) + (sy[i]-sy[i-1])*(sy[i]-sy[i-1]));
    }
    int pos_s = 1;
    int pos_g = 1;
    double tt = T;
    gx[0] = sx[0];
    gy[0] = sy[0];
    while(tt < t[n-1])
    {
      while(tt > t[pos_s])
       {
         pos_s++;
       }
      if(tt == t[pos_s])
      {
        gx[pos_g] = sx[pos_s];
        gy[pos_g] = sy[pos_s];
      }
      else
      {
        gx[pos_g] = sx[pos_s - 1] + vx[pos_s]*(tt - t[pos_s-1]);
        gy[pos_g] = sy[pos_s - 1] + vy[pos_s]*(tt - t[pos_s-1]);
      }
      pos_g++;
      tt += T;
    }
    gx[pos_g] = sx[n-1];
    gy[pos_g++] = sy[n-1];
    rep(i,0,pos_g)
    {
      //printf("%.0f %.0f\n",gx[i],gy[i]);
      if(i == 0)
        continue;
      g_res += sqrt((gx[i]-gx[i-1])*(gx[i]-gx[i-1]) + (gy[i]-gy[i-1])*(gy[i]-gy[i-1]));
    }
    //printf("%.14f %.14f\n",s_res,g_res);
    printf("%.14f\n",fabs(s_res - g_res)/s_res*100);
    return 0;
}