text
stringlengths 49
983k
|
|---|
#include<iostream>
#include<string>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
using namespace std;
int main(){
int n;
while(cin>>n,n){
string s[n];
int num[n];
rep(i,n)cin>>s[i];
rep(i,n)num[i]=s[i].size();
rep(i,n){
int check=0,sum=0;
for(int j=i;sum<=31;j++){
sum+=num[j];
if(sum==5)check|=1;
else if(sum==12)check|=(1<<1);
else if(sum==17)check|=(1<<2);
else if(sum==24)check|=(1<<3);
else if(sum==31)check|=(1<<4);
}
if(check==(31)){
cout<<i+1<<endl;
break;
}
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int num[5]={5,7,5,7,7},n,cnt=0,step,size,ie,f=0;
string s[40];
cin >> n;
while(n!=0){
cnt=0;
step=0;
for(int i=0;i<n;i++){
cin >> s[i];
}
for(int i=0;i<n;i++){
f=0;
ie=0;
for(int j=0;j<5;j++){
size=0;
while(num[j]>size){
size += s[i+ie].length();
ie++;
}
if(num[j]!=size){
f=1;
break;
}
}
if(f==0){
cout << i+1<<endl;
break;
}
}
cin >> n;
}
}
|
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
while(1){
int n; cin >> n;
if(!n) return 0;
vector<int>z;
for(int i=0;i<n;i++){
string a; cin >> a; z.push_back(a.size());
}
for(int i=0;i<n;i++){
int cur = 0; int cnt = 0;
for(int j=i;j<z.size();j++){
cur += z[j];
if(cur < 5) continue;
if(cur > 7) goto fail;
if(cur == 5 && (cnt==0||cnt==2)){
cnt++; cur = 0;
}
else if(cur == 7 && (cnt==1||cnt==3||cnt==4)){
cnt++; cur = 0;
}
if(cnt == 5){
printf("%d\n",i+1); goto nxt;
}
}
fail:;
}
nxt:;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
int tanka[]={5,7,5,7,7};
while(cin>>n,n){
vector<string> w(n);
for(int i=0;i<n;i++)cin>>w[i];
for(int i=0;i<n;i++){
int inde=0;
int cnt=0;
for(int j=i;j<n;j++){
cnt+=w[j].size();
if(cnt==tanka[inde]){
inde++;
cnt=0;
}
if(inde==5) break;
}
if(inde==5){
cout<<i+1<<endl;
break;
}
}
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
while(1) {
cin >> n;
if(n == 0) break;
vector<string> w(n);
for(int i = 0; i < n; i++) {
cin >> w[i];
}
for(int i = 0; i < n; i++) {
vector<int> tanku{ 5, 7, 5 ,7, 7 };
int k = 0;
for(int j = 0; i+j < n; j++) {
tanku[k] -= w[i+j].size();
if(tanku[k] == 0) k++;
else if(tanku[k] < 0) break;
}
if(tanku[0] == 0 && tanku[1] == 0
&& tanku[2] == 0 && tanku[3] == 0
&& tanku[4] == 0) {
cout << i+1 << endl;
break;
}
else continue;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int solve(int n, const vector<string>& w) {
vector<int> five(n + 1, -1), seven(n + 1, -1);
rep(i, n) {
for (int j = i, l = 0; j < n && l < 7; ++j) {
l += w[j].size();
if (l == 5) five[i] = j;
if (l == 7) seven[i] = j;
}
}
rep (i, n) {
int k = i;
bool ok = true;
rep(j, 5) {
k = (j == 0 || j == 2 ? five[k] : seven[k]) + 1;
if (k == 0) {
ok = false;
break;
}
}
if (ok) return i + 1;
}
return -1;
}
int main() {
for (int n; cin >> n, n;) {
vector<string> w(n);
for (auto& e : w) cin >> e;
cout << solve(n, w) << endl;
}
}
|
#include<bits/stdc++.h>
int i,j,p,n,q,a[9]={5,7,5,7,7,-1},d[50];char s[50];
int main(){for(;scanf("%d\n",&n),n;){for(i=0;i<n;)d[i++]=strlen(gets(s));
for(i=j=0;j<6;i++)for(p=i,j=q=0;q>=0&&(q=a[j]);)for(j++;q>0;)q-=d[p++];
printf("%d\n",i);
}}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
int tanku[5] = { 5,7,5,7,7 };
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
vector<string> strings(n);
for (int i = 0; i < n; i++) {
cin >> strings[i];
}
int ans;
for (int i = 0; i < n; i++) {
bool flag = true;
int cur = 0;
int size = 0;
for (int j = i; j < n; j++) {
size += strings[j].size();
if (size > tanku[cur]) {
flag = false;
break;
}
if (size == tanku[cur]) {
cur++;
size = 0;
if (cur == 5) {
break;
}
}
}
if (flag == true) {
ans = i + 1;
break;
}
}
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
using namespace std;
vector<string> goku;
int checkKu(int bgn, int chlen) {
int len = 0;
int i = 0;
while (1) {
len += goku[bgn+i].size();
i+=1;
if (len > chlen)return -1;
else if (len == chlen)return i;
}
}
bool solve(int start) {
int Ku[5] = { 5,7,5,7,7 }, k = start;
for (int i = 0; i < 5; i++) {
int j = checkKu(k, Ku[i]);
//cout << j << endl;
if (j > 0)k += j;
else return false;
}
return true;
}
int main() {
while (1) {
int n;
goku.clear();
cin >> n;
if (n == 0)break;
//input
for (int i = 0; i < n; i++) {
string str;
cin >> str;
goku.push_back(str);
}
int s = 0;
while (1) {
if (solve(s))break;
else s++;
}
cout << s + 1 << endl;
}
return 0;
}
|
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int s[]={5,7,5,7,7};
int main(){
int n;
while(cin>>n&&n!=0){
vector<int> w(n);
string tmp;
for(int i=0;i<n;i++){
cin >> tmp;
w[i] = tmp.size();
}
for(int i=0;i<n;i++){
int x=0;
int y=0;
for(int j=i;j<n;j++){
x += w[j];
if(x==s[y]){
if(y==4){
cout << i+1 << endl;
goto lll;
}
x = 0;
y++;
}else if(x>s[y]){
break;
}
}
}
lll:;
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(){
string w;
int len[40];
int tanku[]={5,7,5,7,7};
int n,sum=0;
for(;;){
cin>>n;
if(n==0) break;
for(int i=0;i<n;i++){
cin>>w;
len[i]=w.size();
sum+=len[i];
}
for(int i=0,jud=0;i<n;i++){
if(sum<27) break;
for(int j=i,k=0,m=0;j<n;j++){
if(m+len[j]>tanku[k]) break;
else if(m+len[j]==tanku[k]){
k++; m=0;
}
else m+=len[j];
if(k==5){
cout<<i+1<<endl; jud=1; break;
}
}
if(jud) break;
}
}
}
|
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
std::string words[40];
const std::array<int, 5> N57577 = { 5, 7, 5, 7, 7 };
int main()
{
while (true) {
int n;
std::cin >> n;
if (n == 0) return 0;
for (int i = 0; i < n; i++) {
std::cin >> words[i];
}
for (int i = 0; i < n; i++) {
int j = i;
bool valid_tanka = true;
for (int wn : N57577) {
int count = 0;
while (j < n) {
count += words[j++].size();
if (count >= wn) break;
}
if (count != wn) {
valid_tanka = false;
break;
}
}
if (valid_tanka) {
std::cout << (i + 1) << std::endl;
break;
}
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define inf 1e9
#define ll long long
#define ull unsigned long long
#define M 1000000007
#define P pair<int,int>
#define PLL pair<ll,ll>
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define RFOR(i,m,n) for(int i=m;i>=n;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n,0)
#define all(a) a.begin(),a.end()
const int vx[4] = {0,1,0,-1};
const int vy[4] = {1,0,-1,0};
#define PI 3.14159265
int a[10]={5,7,5,7,7};
void f(int n){
string s[100];
rep(i,n){
cin>>s[i];
}
rep(i,n){
int k=0;
int t=0;
FOR(j,i,n){
t+=s[j].length();
if(t==a[k]){
k++;
t=0;
}
}
if(k==5){
cout<<i+1<<endl;
return;
}
}
}
int main(){
int n;
while(1){
cin>>n;
if(n==0) break;
f(n);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
while(1){
int N;
cin >> N;
if(!N) break;
string s[N];
for(int i = 0; i < N; i++) cin >> s[i];
const vector<int> po = {5, 7, 5, 7, 7};
for(int i = 0; i < N; i++){
int index = 0;
vector<int> yo = po;
for(int j = i; j < N; j++){
if(index == 5) break;
if(yo[index] < s[j].size()) break;
yo[index] -= s[j].size();
if(!yo[index]) index++;
}
if(index == 5){
cout << i + 1 << endl;
break;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
int len[101];
string s;
int num[5]={5,7,5,7,7};
while(1){
cin>>n;
if(n==0)break;
for(int i=0;i<n;i++){
cin>>s;
len[i]=s.length();
}
int ans=0;
for(int i=0;i<n;i++){
int sum=0,c=0;
for(int j=i;j<n;j++){
sum+=len[j];
if(sum==num[c]){
sum=0;
c++;
}
else if(num[c]<sum)break;
if(c==5)break;
}
if(c==5){
ans=i;
break;
}
}
cout<<ans+1<<endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main(void) {
int N;
while (cin >> N, N) {
vector<string> words(N);
for (int i = 0; i < N; i++) {
cin >> words[i];
}
int tanku_size[] = {5, 7, 5, 7, 7};
for (int i = 0; i < N; i++) {
int tanku_pos = 0;
int letter_size = 0;
for (int j = i; j < N; j++) {
letter_size += words[j].size();
if (letter_size > tanku_size[tanku_pos]) break;
if (letter_size == tanku_size[tanku_pos]) {
tanku_pos++;
letter_size = 0;
}
}
if (tanku_pos == 5) {
cout << i + 1 << endl;
break;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
using namespace std;
int n;
string w[50];
int limit[] = {5,7,5,7,7};
int main() {
while( cin >> n, n ) {
rep(i,n) cin >> w[i];
rep(i,n) {
int index = 0;
int sum = 0;
REP(j,i,n) {
sum += (int)w[j].size();
if( sum == limit[index] ) {
++index;
sum = 0;
if( index >= 5 ) {
cout << i+1 << endl;
goto Fin;
}
} else if( sum > limit[index] ) {
break;
}
}
}
Fin:;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tanku[5] = {5,7,5,7,7};
int main(){
int n;
while(scanf("%d",&n), n != 0){
string w[40];
for(int i=0;i<n;++i)cin >> w[i];
for(int i=0;i<n;++i){
int k=0, cnt=0, j=i;
while(k < 5 && j < n){
cnt += w[j].size();
if(cnt > tanku[k])break;
if(cnt == tanku[k]){
++k;
cnt = 0;
}
++j;
}
if(k == 5){
printf("%d\n",i+1);
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(cin >> n, n){
int len[] = {5, 7, 5, 7, 7};
string w[44];
for(int i = 0; i < n; i++) cin >> w[i];
int ans = 0;
for(int i = 0; i < n; i++){
int cnt = 0, idx = 0;
for(int j = i; j < n; j++){
cnt += w[j].size();
if(cnt == len[idx]){
cnt = 0, idx++;
if(idx == 5) break;
}else if(cnt > len[idx]){ idx = -1; break;}
}
if(idx == 5){ ans = i; break;}
}
cout << ans+1 << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(void){
while(true){
int n;
cin >> n;
if(n == 0){ break; }
string input;
vector<int> w(n);
for(int i = 0; i < n; i++){
cin >> input;
w[i] = input.length();
}
int tank[] = {5, 7, 5, 7, 7};
for(int i = 0; i < n; i++){
int phase = 0;
int nowCount = 0;
for(int j = i; j < n && phase < 5; j++){
nowCount += w[j];
if(nowCount == tank[phase]){
nowCount = 0;
phase++;
}
else if(nowCount > tank[phase]){ break; }
}
if(phase == 5){
cout << i + 1 << endl;
break;
}
}
}
return 0;
}
|
#include<cstdio>
#include<cstring>
int n,len[40];
char word[11];
int solve(int pos) {
int rest;
rest = 5;
while (rest > 0) {
rest -= len[pos++];
if (rest < 0)return 0;
}
rest = 7;
while (rest > 0) {
rest -= len[pos++];
if (rest < 0)return 0;
}
rest = 5;
while (rest > 0) {
rest -= len[pos++];
if (rest < 0)return 0;
}
rest = 7;
while (rest > 0) {
rest -= len[pos++];
if (rest < 0)return 0;
}
rest = 7;
while (rest > 0) {
rest -= len[pos++];
if (rest < 0) return 0;
}
return 1;
}
int main() {
while (1) {
scanf("%d\n", &n);
if (n == 0)break;
for (int i = 0; i < n; i++) {
scanf("%s\n", word);
len[i] = strlen(word);
}
for (int j = 0; j < n; j++) {
if (solve(j)) {
printf("%d\n", j + 1);
break;
}
}
}
}
|
#include <cstdio>
#include <cstring>
int n, l[44]; char c[12];
int main() {
while (scanf("%d", &n), n) {
for (int i = 0; i < n; i++) scanf("%s", c), l[i] = strlen(c);
for (int i = 0; i < n; i++) {
int s = 0, v = 0;
for (int j = i; j < n && s < 5; j++) {
v += l[j];
if (3 % (s + 1) == 0) {
if (v > 5) break;
else if (v == 5) s++, v = 0;
}
else {
if (v > 7) break;
else if (v == 7) s++, v = 0;
}
}
if (s == 5) {
printf("%d\n", i + 1); break;
}
}
}
}
|
#include <iostream>
#define FOR(i,k,n) for (int (i)=(k); (i)<(n); ++(i))
#define REP(i,n) FOR(i,0,n)
using namespace std;
int gositigo[5] = {5,7,5,7,7};
int main(){
int n;
while(cin >> n && n != 0){
int w[n],pos = 0;
string str;
REP(i,n){
cin >> str;
w[i] = str.length();
}
REP(i,n){
int a,s;
s = i;
REP(j,5){
a = 0;
int l = w[s];
while(l < gositigo[j]){
a++;
l += w[s + a];
}
if(l != gositigo[j]){goto NEXT;}
s += a + 1;
}
pos = i+1;
break;
NEXT: continue;
}
cout << pos << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main(){
while(true){
int n;
cin >> n;
if(n == 0)
break;
vector<string> w(n);
for(int i=0; i<n; i++)
cin >> w[i];
int tanku[5] = {5, 7, 5, 7, 7};
bool judge = false;
for(int i=0; i<n; i++){
int place = i;
for(int j=0; j<5; j++){
int sum = 0;
while(place <= n-1){
sum += w[place].size();
place++;
if(j == 4 && sum == tanku[j]){
cout << i+1 << endl;
judge = true;
break;
}
if(sum >= tanku[j])
break;
}
if(sum > tanku[j])
break;
}
if(judge == true)
break;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(n);i++)
#define ALL(v) (v).begin(),(v).end()
#define int long long
typedef pair<int,int> P;
//-----------------------------------------------------------------------
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while(cin>>n,n){
vector<int> v(n);
REP(i,n){
string s; cin>>s;
v[i]=s.size();
}
REP(i,n){
int pos=i;
int A[]={5,7,5,7,7};
REP(j,5){
int cnt=0;
while(pos<n && cnt<A[j]) cnt+=v[pos++];
if(cnt!=A[j]) goto g;
}
cout<<i+1<<endl;
break;
g:;
}
}
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
vector<string> w(n);
for (int i = 0; i < n; i++) {
cin >> w[i];
}
int cnt1 = 0;
int cnt2 = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
cnt2 += w[j].size();
if ((cnt1 == 0 || cnt1 == 2) && cnt2 > 5 || cnt2 > 7) {
cnt1 = 0;
cnt2 = 0;
break;
}
if ((cnt1 == 0 || cnt1 == 2) && cnt2 == 5 ||
(cnt1 == 1 || cnt1 == 3) && cnt2 == 7) {
cnt1++;
cnt2 = 0;
}
if (cnt1 == 4 && cnt2 == 7) {
cout << i + 1 << endl;
i = n;
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long long LL;
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int main(void)
{
for(;;){
int n;
cin >> n;
if(!n) return 0;
vector<string> p(n);
REP(i,n) cin >> p[i];
REP(i,n){
int tmp=0,count=0;
FOR(j,i,n){
tmp+=p[j].size();
if(tmp==5||tmp==12||tmp==17||tmp==24||tmp==31) ++count;
if(tmp>=31) break;
}
if(count==5){
cout << i+1 << endl;
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin>>n,n){
string str[50];
for(int i=0;i<n;i++)cin>>str[i];
int num[]={5,7,5,7,7},ans=1000000;
for(int i=0;i<n;i++){
for(int j=i,idx=0,cnt=0;j<n;j++){
cnt+=str[j].size();
if(cnt==num[idx]) idx++,cnt=0;
if(cnt>num[idx])break;
if(idx==5) ans=min(ans,i);
}
}
cout <<ans+1<<endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
int N;
while (cin>>N, N) {
vector<string> s(N);
int num[] = {5, 7, 5, 7, 7};
for (int i=0; i<N; i++) cin>>s[i];
for (int i=0; i<N; i++) {
bool ok=true;
int idx=i;
for (int j=0; j<5; j++) {
int len = s[idx].size();
++idx;
while (idx<N && len<num[j]) len+=s[idx++].size();
if(idx > N) {
ok = false;
break;
}
if (len != num[j]) {
ok=false;
}
}
if (ok) {
cout << i+1 << endl;
break;
}
}
}
}
|
#include<iostream>
#include<vector>
#include<string>
using namespace std;
int check(vector<int> tanka){
int roule[] = {5,7,5,7,7};
int index = 0, i = 0, t = 0;
int sum = 0;
while(i < 5){
do{
sum += tanka[index+t];
t++;
}while(sum < roule[i]);
if(sum > roule[i]){
index++;
i = 0;
t = 0;
}else{
i++;
}
sum = 0;
}
return index+1;
}
int main(){
vector<int> tanka;
vector<int> res;
int n;
do{
cin >> n;
for(int i=0;i<n;i++){
string tmp;
cin >> tmp;
tanka.push_back(tmp.size());
}
if(n > 0)
res.push_back(check(tanka));
tanka.clear();
tanka.shrink_to_fit();
}while(n > 0);
for(auto num : res){
cout << num << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
while(1){
int word[5]={5,7,5,7,7},n;
cin>>n;
if(n==0) break;
string str[41];
for(int i=1;i<=n;i++)
cin>>str[i];
for(int i=1;i<n;i++){
int x=0,cnt=str[i].size();
if(cnt==word[x])x++,cnt=0;
for(int j=i+1;j<=n;j++){
cnt+=str[j].size();
if(cnt==word[x])x++,cnt=0;
if(x==5) break;
}
if(x==5){cout<<i<<endl;break;}
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define SORT(c) sort((c).begin(),(c).end())
#define IINF INT_MAX
#define LLINF LLONG_MAX
#define DEBUG false
typedef long long ll;
typedef pair<int, int> ii;
int phrase[] = {5, 7, 5, 7, 7};
int main() {
int n;
while(cin >> n, n){
vector<int> w(n);
rep(i, n){
string s;
cin >> s;
w[i] = s.size();
}
int ans = -1;
rep(i, n){
if(ans != -1) break;
int pos = 0;
int cnt = 0;
REP(j, i, n){
if(cnt + w[j] > phrase[pos]) break;
else if(cnt + w[j] == phrase[pos]){
pos++;
cnt = 0;
}
else cnt += w[j];
if(pos == 5) {
ans = i + 1;
break;
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<list>
#include<string>
using namespace std;
bool solve()
{
int n; cin >> n;
vector<string> w(n);
if (n == 0)return false;
for (int i = 0; i < n; ++i)
{
cin >> w[i];
}
for (int i = 0; i < w.size(); ++i)
{
list<int> mojisu{ 5,7,5,7,7 };
for (int j = i; j < w.size(); ++j)
{
mojisu.front() -= (int)w[j].size();
if (mojisu.front() == 0)
{
mojisu.pop_front();
if (mojisu.empty())
{
cout << i+1 << endl;
return true;
}
}
else if (mojisu.front() < 0)
{
break;
}
}
}
}
int main()
{
while (solve())
{
}
}
|
#include <bits/stdc++.h>
#define REP(i,n,N) for(int i=n;i<N;i++)
#define p(S) cout<<S<<endl
using namespace std;
int main(){
int tnk[5]={5,7,5,7,7};
int n;
while(cin>>n,n){
string s[40];
int snum=0,now=0,ans=1;
REP(i,0,n){
cin>>s[i];
}
int j=0;
while(1){
snum+=s[j].size();
j++;
if(snum==tnk[now]){
snum=0;
now++;
}else if(snum>tnk[now]){
snum=0;
now=0;
j=ans;
ans++;
}
if(now==5){
p(ans);
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n)for (int i=0;i<(n);i++)
#define PB push_back
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define ll long long
using namespace std;
int d[5]={5,7,5,7,7};
int num[40];
int n;
bool rec(int s){
int sum=0;
int t[5];
REP(i,5)t[i]=d[i];
int ss=0;
for(int i=s;i<n;i++){
if(t[ss]>0)t[ss]-=num[i];
else{
ss++;
t[ss]-=num[i];
}
}
REP(i,5)if(t[i]!=0)return false;
return true;
}
int main(){
while(1){
cin>>n;
if(n==0)break;
REP(i,n){
string s;cin>>s;
num[i]=s.size();
}
REP(i,n){
if(rec(i)){
cout<<i+1<<endl;
break;
}
}
}
}
|
#include <iostream>
#include <string>
using namespace std;
int search(string s[]) {
int count = 0;
int t = 0;
for (int i = 0; ; i++) {
if (s[i].size() > 5) continue;
int start = i;
for (int j = i; ; j++) {
t += s[j].size();
if (count == 0 || count == 2) {
if (t == 5) {
count++;
t = 0;
} else if (t > 5) {
count = 0;
t = 0;
break;
}
} else {
if (t == 7) {
count++;
if (count == 5) return start;
t = 0;
} else if (t > 7) {
count = 0;
t = 0;
break;
}
}
}
}
}
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) return 0;
string s[n];
for (int i = 0; i < n; i++)
cin >> s[i];
int ans = search(s);
cout << ans + 1 << endl;
}
}
|
#include<iostream>
#include<vector>
#include<string>
using namespace std;
int main(void) {
int n;
int tanku[]={5,7,5,7,7};
while (true) {
cin >> n;
if (n==0) {
break;
}
string a;
vector<int> w(n);
for (int i=0; i<n; i++) {
cin >> a;
w[i]=a.size();
}
for (int i=0; i<n; i++) {
int sum=0;
int k=0;
bool flag=false;
for (int j=i; j<n; j++) {
sum+=w[j];
if (sum>tanku[k]) {
break;
}
if (sum==tanku[k]) {
k++;
sum=0;
}
if (k==5) {
flag=true;
break;
}
}
if (flag) {
cout<<i+1<<endl;
break;
}
}
}
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
using namespace std;
int main(){
int n,wa[41],flag[5];
char s[40][20];
while(1){
cin>>n;
if(n==0)
break;
wa[0]=0;
for(int i=0;i<n;i++){
scanf("%s",s[i]);
wa[i+1]=strlen(s[i])+wa[i];
}
for(int i=0;i<n-1;i++){
for(int j=0;j<5;j++)
flag[j]=0;
for(int k=i;k<=n;k++){
if(wa[k]-wa[i]==5)
flag[0]=1;
else if(wa[k]-wa[i]==12)
flag[1]=1;
else if(wa[k]-wa[i]==17)
flag[2]=1;
else if(wa[k]-wa[i]==24)
flag[3]=1;
else if(wa[k]-wa[i]==31)
flag[4]=1;
}
if(flag[0]==1&&flag[1]==1&&flag[2]==1&&flag[3]==1&&flag[4]==1){
cout<<i+1<<endl;
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
auto c = vector<int>(n);
for (int i = 0; i < n; ++i) {
string w; cin >> w;
c[i] = w.length();
}
auto solve = [&]() {
for (int i = 0; i < n; ++i) {
auto phrase = vector<int>{5, 7, 5, 7, 7};
int idx = 0;
for (int j = i; j < n; ++j) {
if (phrase[idx] > 0) phrase[idx] -= c[j];
if (phrase[idx] < 0) break;
if (phrase[idx] == 0) ++idx;
if (idx == 5) return i + 1;
}
}
return 0;
};
cout << solve() << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
char s[50],a[9]={6,8,6,8,8};
int main(){for(int i,j,p,n,q;scanf("%d\n",&n),n;){for(i=0;i<n;s[i++]=strlen(gets(s+i)));
for(i=j=0;j<6;i++)for(p=i,j=q=0;q>=0;)for(q=a[j++]-1;q>0;q-=s[p++]);
printf("%d\n",i);
}}
|
#include<iostream>
#include<string.h>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#define ll long long int
#define ld long double
#define INF 1000000000
#define EPS 0.0000000001
#define rep(i,n) for(i=0;i<n;i++)
using namespace std;
typedef pair<int, int> pii;
int main()
{
int n;
while(1){
cin>>n;
if(n==0)break;
string str;
int len[45];
int i,j;
int ans;
rep(i,n){
cin>>str;
len[i]=str.size();
}
rep(i,n){
int tanku[5]={5,7,5,7,7};
int now=0;
for(j=i;j<n;j++){
if(len[j]>tanku[now])break;
if(len[j]==tanku[now])now++;
else tanku[now]-=len[j];
if(now==5) goto ANS;
}
}
ANS:cout<<i+1<<endl;
}
}
|
#include<iostream>
#include<string>
using namespace std;
int main(){
while(true){
int n;
cin >> n;
if(n==0) break;
int len[n];
for(int i=0; i<n; i++){
string w;
cin >> w;
len[i] = w.size();
}
for(int i=0; i<n; i++){
bool flag = false;
int sta = 0; //区切り
int sum = 0; //文字数の合計
for(int j=i; j<n; j++){
sum = sum + len[j];
if(sum==5 || sum==12 || sum==17 || sum==24 || sum==31){
sta++;
}
if(sta==5){
flag = true;
break;
//}else if(sum>=31){
// break;
}
}
if(flag){
cout << i+1 << endl;
break;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9+7;
void solve(int N){
vector<int> V(N);
rep(i,0,N){
string s;
cin >> s;
V[i] = s.size();
}
int arr[] = {5,7,5,7,7};
rep(i,0,N){
int sum = 0, cur = 0;
bool ok = 1;
rep(j,i,N){
sum += V[j];
if(sum > arr[cur]){
ok = 0;
break;
}else if(sum == arr[cur]){
cur++;
sum = 0;
}
if(cur == 5)break;
}
if(!ok || cur != 5)continue;
cout << i+1 << endl;
return;
}
}
int main(){
int N;
cin >> N;
while(N){
solve(N);
cin >> N;
}
}
|
#include<bits/stdc++.h>
int main(){for(char s[50],i,j,p,q;p=atoi(gets(s)),p;printf("%d\n",i)){for(i=0;i<p;s[i++]=strlen(gets(s+i)));for(i=j=0;j<7;)for(p=i++,j=q=1;q>0;)for(q=j++>5?0:j-2&&j-4?8:6;q>1;q-=s[p++]);}}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,h[40];
string a;
while(cin>>n,n){
for(int i=0;i<n;i++)cin>>a,h[i]=a.size();
for(int i=0;i<n;i++){
int now=i,nt=0,nn=0,f=0;
while(1){
if(nt==5){
f=1;
break;
}
if(nt==0||nt==2){
if(nn>5)break;
if(nn==5)nt++,nn=0;
}else{
if(nn>7)break;
if(nn==7)nt++,nn=0;
}
nn+=h[now];
now++;
}
if(f){
cout<<i+1<<endl;
break;
}
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int n, p[] = { 5, 7, 5, 7, 7 }, ans;
string s[40];
int main() {
while (true) {
cin >> n;
if (!n)break;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
ans = 0;
for (int i = 0; i < n; i++) {
int index = 0;
int sum = 0;
for (int j = i; j < n; j++) {
sum += s[j].length();
if (sum == p[index]) {//次に進む
index++;
sum = 0;
}
else if (sum > p[index]) {//もうあり得ない
break;
}
if (index > 4) {
ans = i + 1;
break;
}
}
if (ans > 0)break;
}
cout << ans << endl;
}
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int tanku[] = {5, 7, 5, 7, 7};
void solve()
{
int n;
while (cin >> n, n)
{
vector<int> w(n);
for (int i = 0; i < n; ++i)
{
string s;
cin >> s;
w[i] = s.size();
}
for (int i = 0; i < n; ++i)
{
int pos = 0;
int cnt = 0;
for (int j = i; j < n; ++j)
{
cnt += w[j];
if (cnt == tanku[pos])
{
++pos;
cnt = 0;
}
if (pos >= 5 || cnt > tanku[pos])
{
break;
}
}
if (pos == 5)
{
cout << i + 1 << endl;
break;
}
}
}
}
int main()
{
solve();
return(0);
}
|
#define _USE_MATH_DEFINES
#include<stdio.h>
#include<string>
#include<iostream>
#include<cctype>
#include<cstdio>
#include<vector>
#include<stack>
#include <algorithm>
#include<math.h>
#include<set>
#include<map>
#include<iomanip>
using namespace std;
int main(){
int n;
while(1){
cin>>n;
if(!n)break;
int p[50]={};;
for(int i=0;i<n;i++){
string y;
cin>>y;
p[i]=y.size();
}
for(int i=0;i<n;i++){
bool a=0,b=0,c=0,d=0,e=0;
int r=0;
for(int j=i;j<n;j++){
r+=p[j];
if(!a&&r==5)a++;
if(!a&&r>5)break;
if(r==12)b++;
if(!b&&r>12)break;
if(r==17)c++;
if(!c&&r>17)break;
if(r==24)d++;
if(!d&&r>24)break;
if(r==31)e++;
if(!e&&r>31)break;
if(a&&b&&c&&d&&e){
cout<<i+1<<endl;
break;
}
}
if(a&&b&&c&&d&&e){
break;
}
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int a[5] = {5,7,5,7,7};
int main(){
int n;
while(cin >> n, n){
int w[n];
string s;
for(int i = 0; i < n; i++){
cin >> s;
w[i] = s.length();
}
int ans;
for(int i = 0; i < n; i++){
int pos = 0, tmplen = 0;
for(int j = i; j < n; j++){
if(tmplen < a[pos]) tmplen += w[j];
if(tmplen > a[pos]) break;
if(tmplen == a[pos]) pos++, tmplen = 0;
if(pos == 5){
ans = i;
break;
}
}
if(pos == 5) break;
}
cout << ans+1 << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define Pasharin using namespace std
Pasharin;
int main(){
int n;
int a[]={5,7,5,7,7};
while(cin>>n,n){
string s[n];
int x=0,y=0;
for(int i=0;i<n;++i) cin>>s[i];
int j=0;
bool flag=false;
for(j=0;j<n;++j){
for(int i=j;i<n;++i){
x+=(int)s[i].size();
if(x==a[y]){
x=0;
y++;
if(y==5){
cout<<j+1<<endl;
flag=true;
break;
}
}
else if(x>a[y]){
x=0,y=0;
break;
}
}
if(flag) break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[5] = {5,7,5,7,7};
int main(){
int n;
while(cin >> n,n){
vector<int> v;
for(int i=0;i<n;i++){
string s;
cin >> s;
v.emplace_back(s.size());
//cout << s.size() << endl;
}
int sum=0;
int idx=0;
int start=0;
for(int unsigned i=0;i<v.size();i++){
sum+=v[i];
//cout << v[i] << " " << sum << " " << d[idx] << " " << i << " " << " " << idx << " " << start << endl;
if(sum == d[idx]){
idx++;
sum=0;
} else if(sum > d[idx]){
idx=0;
i = start;
start=i+1;
sum=0;
}
if(idx >= 5){
cout << start+1 << endl;
break;
}
}
//cout << endl;
}
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;
int main() {
int n;
while (cin >> n,n )
{
vector<string> w;
for (int i = 0;i < n;++i) {
string tmp;
cin >> tmp;
w.push_back(tmp);
}
int flag = 0;
int len = 0;
int output = 100000000;
for (int i = 0;i < n;++i) {
flag = 0;
len = 0;
for (int j = i; j< n;++j) {
len += w[j].size();
if (flag == 0 || flag == 2) {
if (len == 5) {
len = 0;
flag++;
}
else if (len > 5) {
break;
}
}
else {
if (len == 7) {
len = 0;
flag++;
}
else if (len > 7) {
break;
}
}
}
if (flag >= 5) {
output = i + 1;
break;
}
}
cout << output << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> A;
int table[] = {5, 7, 5, 7, 7};
int solve(){
for(int i=0; i<N; i++){
bool ok = true;
int cur = i;
for(int j=0; j<5; j++){
int s = 0;
while(cur<N && s<table[j]){
s += A[cur++];
}
if(table[j] != s){
ok = false;
break;
}
}
if(ok)
return i+1;
}
return -1;
}
int main(){
while(cin >> N, N){
A.clear();
for(int i=0; i<N; i++){
string s; cin >> s;
A.push_back(s.size());
}
cout << solve() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin >> n and n){
vector<int> v;
for(int i = 0 ; i < n ; i++){
string s;
cin >> s;
v.push_back(s.size());
}
for(int i = 0 ; i < n ; i++){
int j = i;
int s = 0;
int f = 1;
while( j < n and s < 5 ) s += v[j++];
if( s != 5 ) f = 0;
s = 0;
while( j < n and s <7 ) s += v[j++];
if( s != 7 ) f = 0;
s = 0;
while( j < n and s < 5 ) s += v[j++];
if( s != 5 ) f = 0;
s = 0;
while( j < n and s < 7 ) s += v[j++];
if( s != 7 ) f = 0;
s = 0;
while( j < n and s < 7) s += v[j++];
if( s != 7 ) f = 0;
if( f ){
cout << i+1 << endl;
break;
}
}
}
}
|
#include<iostream>
using namespace std;
signed main(){
while(1){
int n;
cin>> n;
if(!n) break;
int w[n];
for(int i=0; i<n; i++){
string s;
cin>> s;
w[i]=s.size();
}
int b[]={5, 7, 5, 7, 7};
for(int i=0; i<n; i++){
int a=0, p=0;
for(int j=i; j<n; j++){
a+=w[j];
if(a>b[p]){
goto turai;
}else if(a==b[p]){
p++;
if(p==5) break;
a=0;
}
}
if(p==5){
cout<< i+1<< endl;
break;
}
turai:;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int check[]={5,7,5,7,7};
int main(){
int n;
while(cin >> n, n){
vector<string> s(n);
for(int i=0;i<n;i++)
cin >> s[i];
int ans=0;
for(int f=0;f<n;f++){
int p=f;
bool ok=true;
for(int k=0;k<5;k++){
int nowl=0;
while(nowl<check[k]){
nowl+=s[p].size();
p++;
}
if(nowl!=check[k])
ok=false;
}
if(ok){
ans=f+1;
break;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <iostream>
#define rep(i,n) for(int i = 0; i < n; ++i)
using namespace std;
int main(void){
int n;
while(cin >> n,n){
string words[55];
rep(i,n) cin >> words[i];
rep(start,n){
int num = 0,step = 0;
int tar[5]={5,7,5,7,7};
for(int j = start; j < n;++j){
num += words[j].size();
if(step < 5 and tar[step] == num){
step++;
num = 0;
}
}
if(step == 5){
cout << start+1 << endl;
break;
}
}
}
return 0;
}
|
#include <iostream>
#define REP(i, a, n) for(int i = a; i <= n; i++)
using namespace std;
int N, len[41];
int p[6] = { 0, 5, 7, 5, 7, 7 };
bool check(int s) {
// cout << s << endl;
REP(i, 1, 5) {
int d = 0;
while(s <= N) {
d += len[s++];
// cout << " " << s << " " << i << " " << d << endl;
if(d > p[i]) return false;
if(d == p[i]) break;
}
if(d < p[i]) return false;
}
return true;
}
int main(void) {
while(cin >> N, N) {
REP(i, 1, N) {
string S; cin >> S;
len[i] = S.length();
}
REP(i, 1, N) {
if(!check(i)) continue;
cout << i << endl;
goto CONTINUE;
}
CONTINUE: continue;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
while(1) {
bool end = false;
int n;
cin >> n;
if(n == 0) return 0;
int w[n];
for(int i = 0; i < n; i++) {
string s;
cin >> s;
w[i] = s.size();
}
// for(int i = 0; i < n; i++) cout << w[i] << " ";
// cout << endl;
int tanku[5] = {5, 7, 5, 7, 7};
for(int i = 0; i < n; i++) {
if(end) break;
int k = 0;
for(int j = 0; j < 5; j++) {
if(end) break;
int sum = 0;
while(sum < tanku[j]) {
sum += w[i+k];
k++;
}
// cout << sum << " :" << j << " ";
if(sum != tanku[j]) break;
if(j == 4) {
cout << i+1 << endl;
end = true;
}
}
}
}
}
|
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n;
int cnt[101];
int cal[5]={5,7,5,7,7,};
int main(void){
while(1){
scanf("%d",&n);
if(n==0)break;
for(int i=0;i<n;i++){
string str;
cin >> str;
cnt[i]=str.size();
}
int res=-1;
for(int i=0;i<n;i++){
if(res!=-1)continue;
int now=0;
int len=0;
for(int j=i;j<n;j++){
len+=cnt[j];
if(len==cal[now]){
now++;
len=0;
}else if(len>cal[now]){
break;
}
if(now==5){
res=i;
break;
}
}
}
printf("%d\n",res+1);
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define reps(i,f,n) for(int i=f; i<n; ++i)
#define rep(i,n) reps(i,0,n)
void solve(int n)
{
vector<int> v(n);
rep(i, n){
string s;
cin >> s;
v[i] = s.size();
}
const int len[] = {5, 7, 5, 7, 7};
rep(i, n){
int p = 0, j = i;
while(p < 5 && j < n){
int cnt = len[p];
for(; cnt && j<n; ++j){
cnt -= v[j];
if(cnt < 0) goto end;
}
++p;
}
if(p == 5){
cout << i+1 << endl;
break;
}
end:;
}
}
int main()
{
int n;
while(cin >> n, n){
solve(n);
}
}
|
#include <iostream>
#include <string>
using namespace std;
int main(){
int a,sum,k,l,sta,suc,h[50],han[5]={5,7,5,7,7};
string s;
while(cin>>a){
if(a==0)break;
for(int i=0;i<a;i++){
cin>>s;
h[i]=s.size();
}
suc=0;
for(int i=0;i<a;i++){
sum=0;k=0;l=0;
while(1){
sum+=h[i+k];
if(sum==han[l]){
l++;
sum=0;
}else if(sum>han[l])break;
if(l==5){
suc=1;
break;
}
k++;
if(k>=a)break;
}
if(suc==1){
sta=i;
break;
}
}
cout<<sta+1<<endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <tuple>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
class Solver {
};
int main() {
while (true) {
int n;
cin >> n;
if (n == 0)break;
vector<int> lens;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
lens.emplace_back(s.size());
}
vector<int> cnts{ 5,7,5,7,7 };
int start = -1;
for (int i = 0; i < n; i++) {
int now = 0;
int tmp = 0;
for (int j = i; j < n; j++) {
tmp += lens[j];
if (tmp > cnts[now])break;
if (tmp == cnts[now]) {
now++;
tmp = 0;
if (now == 5) {
start = i;
break;
}
}
}
if (start >= 0)break;
}
cout << start + 1 << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
string w[40];
int lengths[] = {5, 7, 5, 7, 7};
while(cin >> n, n) {
for(int i = 0; i < n; i++) {
cin >> w[i];
}
for(int i = 4; i < n; i++) {
int beforreadidx = 4, len = 0;
for(int j = i; j >= 0; j--) {
len += w[j].length();
if(lengths[beforreadidx] == len) {
len = 0;
beforreadidx--;
if(beforreadidx == -1) {
cout << j + 1 << endl;
break;
}
}
}
if(beforreadidx == -1) break;
}
}
return(0);
}
|
#include <iostream>
using namespace std;
int main()
{
while(1){
int n;
cin >> n;
if(n == 0) break;
string w[n];
bool k[500] = {};
k[0] = true;
string s = "";
int m[n+1];
m[0] = 0;
for(int i = 0; i < n; i++){
cin >> w[i];
s += w[i];
k[s.size()] = true;
m[i+1] = s.size();
}
for(int i = 0; i < n; i++){
if(s.size()-m[i]+1 < 31) continue;
if(k[m[i]] && k[m[i]+5] && k[m[i]+12] && k[m[i]+17] && k[m[i]+24] && k[m[i]+31]){
cout << i+1 << endl;
break;
}
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
int n,l[45],L[45],a,d[5]={5,7,5,7,7};
string s;
int main(){
while(1){
cin>>n;
if(!n)break;
for(int i=1;i<=n;i++){
cin>>s,l[i]=s.size();
L[i]=L[i-1]+l[i];
}
a=0;
for(int i=1;i<=n;i++){
int x=0,s=i;
for(int j=i;j<=n;j++){
if(L[j]-L[s-1]==d[x])x++,s=j+1;
if(!a&&x==5)a=i,cout<<a<<endl;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
char s[50],a[9]={1,6,8,6,8,8},i,j,p,n,q;
int main(){for(;scanf("%d\n",&n),n;printf("%d\n",i)){
for(i=0;i<n;s[i++]=strlen(gets(s+i)));
for(i=j=0;j<7;)for(p=i++,j=q=1;q>0;)for(q=a[j++];q>1;q-=s[p++]);
}}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string w[40];
int lens[] = {5, 7, 5, 7, 7};
while(cin >> n, n) {
for(int i = 0; i < n; ++i) {
cin >> w[i];
}
for(int i = 0; i < n; ++i) {
int len = 0, phrase = 0;
for(int j = i; j < n; ++j) {
len += w[j].size();
if(len == lens[phrase]) {
len = 0;
++phrase;
if(phrase == 5) {
cout << i + 1 << endl;
break;
}
}
}
if(phrase == 5) {
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n;
int t[] = {5,7,5,7,7};
while(cin >> n, n){
vector<int> v(n);
for(int i = 0; i < n; ++i){
string s;
cin >> s;
v[i] = s.size();
}
for(int i = 0; i < n; ++i){
bool a = true;
int j = i;
int tn = 0;
while(tn < 5){
int sum = 0;
while(sum < t[tn]){
sum += v[j];
j++;
if(j==n)break;
}
if(sum == t[tn]){
tn++;
}else{
a = false;
break;
}
}
if(a && tn==5){
cout << i+1 << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<(int)n;++i)
using namespace std;
bool is_57577(const vector<int> &l, int i) {
deque<int> phrases = {5, 7, 5, 7, 7};
for (int j = i; j < l.size(); ++j) {
phrases[0] -= l[j];
if (phrases[0] < 0) return false;
if (phrases[0] == 0) {
phrases.pop_front();
if (phrases.empty()) return true;
}
}
return false;
}
int main() {
while(1){
int n;
cin>>n;
if(!n)break;
vector<int> l(n);
REP(i,n){
string s;
cin>>s;
l[i] = s.size();
}
REP(i,n) {
if(is_57577(l, i)) {
cout << (i+1) << endl;
break;
}
}
}
return 0;
}
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int len[50];
int d[5]={5,7,5,7,7};
int main(){
int n;
string s;
while(true){
cin>>n;
if(n==0)break;
for(int i=0;i<n;i++){
cin>>s;
len[i]=s.size();
}
int ans=100000;
for(int i=0;i<n;i++){
int cnt=0;
int set=0;
int j=i;
bool ok=true;
while(true){
cnt+=len[j];
if(cnt==d[set]){
cnt=0;
set++;
if(set==5)break;
}
if(cnt>d[set]){
ok=false;
break;
}
j++;
if(j==n){
ok=false;
break;
}
}
if(ok){
ans=min(ans,i+1);
}
}
cout<<ans<<endl;
}
return 0;
}
|
#include <iostream>
#include <functional>
#include <algorithm>
#include <string>
using namespace std;
int num[5] = { 5,7,5,7,7 };
int main() {
int n;
int w[53];
while (1) {
cin >> n;
if (n == 0)break;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
w[i] = s.length();
}
for (int i = 0; i < n; i++) {
int now = i;
int x = 0;
int cnt = 0;
int judge = 0;
while (1) {
if (x == 5) {
judge = 1;
break;
}
cnt += w[now++];
if (cnt == num[x]) {
cnt = 0;
x += 1;
}
if (cnt > num[x] || (now >= n&&x!=5))break;
}
if (judge == 1) {
cout << i + 1 << "\n";
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> cnt = {5, 12, 17, 24, 31};
int main(){
while (1){
int n;
cin >> n;
if (n == 0){
break;
}
vector<string> w(n);
for (int i = 0; i < n; i++){
cin >> w[i];
}
vector<int> sum(n + 1, 0);
for (int i = 0; i < n; i++){
sum[i + 1] = sum[i] + w[i].size();
}
set<int> st;
for (int i = 0; i <= n; i++){
st.insert(sum[i]);
}
for (int i = 0; i < n; i++){
bool ok = true;
for (int j = 0; j < 5; j++){
if (!st.count(sum[i] + cnt[j])){
ok = false;
}
}
if (ok){
cout << i + 1 << endl;
break;
}
}
}
}
|
#include<bits/stdc++.h>
char s[50],a[9]={5,7,5,7,7,-1};
int main(){for(int i,j,p,n,q;scanf("%d\n",&n),n;){for(i=0;i<n;s[i++]=strlen(gets(s+i)));
for(i=j=0;j<6;i++)for(p=i,j=q=0;q>=0;)for(q=a[j++];q>0;q-=s[p++]);
printf("%d\n",i);
}}
|
#include<iostream>
#include<string>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<n;i++)
int main(){
while(1){
ll n;
cin >>n;
if(n==0){
break;
}
string name[n];
REP(i,n){
cin>>name[i];
}
ll num[n];
REP(i,n){
num[i]=name[i].length();
}
REP(i,n){
ll len=0;
ll now=i;
while(len<5){
len+=num[now];
now++;
}
if(len==5){
len=0;
while(len<7){
len+=num[now];
now++;
}
if(len==7){
len=0;
while(len<5){
len+=num[now];
now++;
}
if(len==5){
len=0;
while(len<7){
len+=num[now];
now++;
}
if(len==7){
len=0;
while(len<7){
len+=num[now];
now++;
}
if(len==7){
cout<<i+1<<endl;
break;
}
}
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool judge(int* a)
{
int x[5] = {5, 7, 5, 7, 7};
int i = 0;
while(true)
{
if(i==5) return true;
x[i] -= *a++;
if(x[i]<0) return false;
if(x[i]==0) i++;
}
}
int main()
{
int n;
while(cin >> n, n)
{
int a[n];
for(int i=0; i<n; i++)
{
string s;
cin >> s;
a[i] = s.size();
}
for(int i=0; i<n; i++)
{
if(judge(a+i))
{
cout << i+1 << endl;
break;
}
}
}
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <string>
#include <cstring>
using namespace std;
typedef long long int ll;
int n;
int p[]={5,12,17,24,31};
void solve(){
vector<int> a(n+1);
for(int i=0;i<n;i++){
string s; cin >> s;
a[i+1]=a[i]+(int)s.size();
}
for(int i=0;i<n;i++){
int j=0;
for(int k=i+1;k<=n;k++){
if(a[k]==a[i]+p[j]){
j++;
if(j==5)break;
}
}
if(j==5){
printf("%d\n",i+1 );
return;
}
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
while(1){
cin >> n;
if(n==0)break;
solve();
}
}
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define rep(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = int(b) - 1; i >= (int)(a); --i)
using pii = pair<int, int>;
using vi = vector<int>;
int solve(int n) {
vi a(n);
rep(i, 0, n) {
string s;
cin >> s;
a[i] = s.size();
}
const vi seq = { 5, 7, 5, 7, 7 };
rep(i, 0, n) {
int s = 0;
int idx = 0;
bool ng = false;
rep(j, i, n) {
s += a[j];
if (s == seq[idx]) {
s = 0;
idx++;
if (idx == seq.size())break;
}
else if (s > seq[idx]) {
ng = true;
break;
}
}
if (!ng) {
return i + 1;
}
}
return -1;
}
signed main() {
while (1) {
int n;
cin >> n;
if (n == 0) break;
cout << solve(n) << endl;
}
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
const int tanka[] = {5, 7, 5, 7, 7};
int main() {
int n;
while(cin >> n, n) {
vector<int> len(n);
for (int i = 0; i < n; i++) {
string s; cin >> s;
len[i] = s.size();
}
for (int i = 0; i < n; i++) {
int idx = i;
bool flag = true;
for (int j = 0; flag && j < 5; j++) {
int x = 0;
while(idx < n && x < tanka[j]) {
x += len[idx];
idx++;
}
if (x != tanka[j]) flag = false;
}
if (flag) {
cout << i + 1<< endl;
break;
}
}
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
const double PI = 3.1415926535897932384626433832795028841971;
const int INF = 100000000;
const double EPS = 1e-10;
const int MOD = 1000000007;
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n;
string str[40];
void solve(){
rep(i,n) cin >> str[i];
rep(i,n){
int cnt[5] = {5,7,5,7,7};
for(int j = i; j < n; j++){
rep(k,5){
if(cnt[k] != 0){
cnt[k] -= str[j].size();
break;
}
}
}
bool ok = true;
rep(j,5) if(cnt[j] != 0) ok = false;
if(ok){
cout << i+1 << endl;
break;
}
}
}
int main(){
while(cin >> n){
if(n == 0) break;
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
vector<string> s;
for (int i = 0; i < n; ++i) {
string in;
cin >> in;
s.push_back(in);
}
for (int i = 0; i < s.size(); ++i) {
int length = 0;
int cnt = 0;
for (int j = i; j < s.size() && cnt != 5; ++j) {
length += s[j].size();
if ((cnt == 0 || cnt == 2) && length == 5) {
length = 0;
cnt++;
continue;
}
if ((cnt == 1 || cnt == 3 || cnt == 4) && length == 7) {
length = 0;
cnt++;
continue;
}
}
if (cnt == 5) {
cout << i + 1 << endl;
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(int start, const vector<string> &words) {
const array<int, 5> num{{5, 7, 5, 7, 7}};
int idx = 0;
int sum = 0;
for(int i = start; i < words.size(); ++i) {
sum += words[i].size();
if(sum == num[idx]) {
if(++idx == 5) return true;
sum = 0;
}
else if(sum > num[idx]) {
return false;
}
}
return false;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
for(int n; cin >> n && n;) {
vector<string> words(n);
for(auto &e : words) cin >> e;
for(int i = 0; i < n; ++i) {
if(check(i, words)) {
cout << i + 1 << endl;
break;
}
}
}
return EXIT_SUCCESS;
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
while (true) {
int n;
cin >> n;
if (n == 0)
break;
int len[40];
for (int i = 0;i < n;i++) {
string w;
cin >> w;
len[i] = w.size();
}
for (int i = 0;i < n;i++) {
bool flg = false;
int sta = 0;
int sum = 0;
for (int j = i;j < n;j++) {
sum += len[j];
//区切りなら
if (sum == 5 || sum == 12 || sum == 17 || sum == 24 || sum == 31) {
sta++;
}
if (sta == 5) {
flg = true;
break;
}
else if (sum >= 31) {
break;
}
}
if (flg) {
cout << i + 1 << endl;
break;
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
int i,j,d[50],p,n,q,a[5]={5,7,5,7,7};
char s[15];
int main(){
for(n=1;n;){
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%s",s);
d[i]=strlen(s);
}
for(i=0;n;i++){
p=i;
for(j=0;j<5;j++){
q=a[j];
while(q>0){
q-=d[p];p++;
}
if(q<0)break;
}
if(j>4){
printf("%d\n",i+1);
break;
}
}
}
}
|
#include<iostream>
using namespace std;
int main(){
int n, w[5]={5, 7, 5, 7, 7};
string s[40];
while(cin>>n, n){
for(int i=0;i<n;i++) cin>>s[i];
for(int i=0;i<n;i++){
int id=0, sw=0;
bool f=false;
for(int j=i;j<n;j++){
sw+=s[j].size();
if(sw==w[id]){
id++;
sw=0;
}else if(sw>w[id]) break;
if(id==5){
cout<<i+1<<endl;
f=true;
break;
}
}
if(f) break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<long>;
long TMP[5] = {5, 7, 5, 7, 7};
int main() {
int n;
while (1) {
cin >> n;
if (n) {
VI ps;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
ps.push_back(s.size());
}
for (int first = 0; first < n; first++) {
int diff = 0;
bool legal = true;
for (int k = 0; k < 5; k++) {
int acc = 0;
while (acc < TMP[k]) {
acc += ps[first + diff];
diff++;
}
if (acc > TMP[k]) {
legal = false;
break;
}
}
if (legal) {
cout << first+1 << endl;
break;
}
}
} else {
return 0;
}
}
}
|
#include<iostream>
#include<string>
using namespace std;
int main(){
while(true){
int n;
cin>>n;
if(n==0)
break;
int len[40];
for(int i=0;i<n;i++){
string w;
cin>>w;
len[i] = w.size();
}
for(int i=0;i<n;i++){
bool flg=false;
int sta=0;
int sum=0;
for(int j=i;j<n;j++){
sum += len[j];
if(sum==5||sum==12||sum==17||sum==24||sum==31){
sta++;
}
if(sta==5){
flg=true;
break;
}
else if(sum>=31){
break;
}
}
if(flg){
cout<<i+1<<endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[] = {5,7,5,7,7};
signed
main(){
int n;
while(cin >> n && n!=0)
{
vector<int> w(n);
for(int i=0;i<n;i++)
{
string s;
cin >> s;
w[i] = (int)s.size();
}
for(int i=0;i<n;i++)
{
int a[5] = {};
int key = 0;
bool flag = true;
for(int j=i;j<n;j++)
{
if(key == 5){
break;
}
a[key] += w[j];
if(a[key] == d[key]){
key++;
}else if(a[key] < d[key]){
}else if(a[key] > d[key]){
flag = false;
break;
}
}
if(flag){
cout << i+1 << endl;
break;
}
}
}
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <list>
using namespace std;
#define REP(i,x,n) for(int i = x; i < n; i++)
bool solve() {
int n; cin >> n;
if (n == 0)return false;
vector<string> w(n);
REP(i, 0, n)cin >> w[i];
REP(i, 0, n)
{
list<int> mojisu{5,7,5,7,7};
REP(j, i, n)
{
mojisu.front()-=w[j].length();
if (mojisu.front() == 0)
{
mojisu.pop_front();
if (mojisu.empty())
{
cout << i + 1 << endl;
return true;
}
}
else if(mojisu.front() < 0)
{
break;
}
}
}
}
signed main() {
while (solve()) {
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
int n, t, x, j;
string s;
vector<int> v, u;
while (cin >> n, n) {
for (int i = 0; i < n; ++i) {
cin >> s;
v.push_back(s.size());
}
t = 0;
u = {5, 7, 5, 7, 7, 0};
for (int i = 0; i < n; ++i) {
j = i;
t = 0;
x = 5;
while (x >= 0 && t < 5) {
x -= v[j];
if (!x) {
++t;
x = u[t];
} else if (x < 0) break;
++j;
}
if (t == 5) {
cout << i+1 << endl;
break;
}
}
v.erase(v.begin(), v.end());
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(){
int n;
while(cin>>n){
if(n==0) break;
int a[n];
for(int i=0;i<n;i++){
string s;
cin>>s;
a[i]=s.size();
}
int st=0,t=0,ct=0;
for(int i=0;i<n;i++){
for(int j=i;j<n;j++){
t=t+a[j];
if(ct==0||ct==2){
if(t>5){
t=0;
ct=0;
break;
}
else if(t==5){
t=0;
ct++;
}
}
else if(ct==1||ct==3||ct==4){
if(t>7){
t=0;
ct=0;
break;
}
else if(t==7){
t=0;
ct++;
}
}
}
if(ct==5){
st=i+1;
break;
}
}
cout<<st<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
auto c = vector<int>(n);
for (int i = 0; i < n; ++i) {
string w; cin >> w;
c[i] = w.length();
}
auto s = vector<int>(n + 1, 0);
auto phrase = vector<int>{5, 7, 5, 7, 7};
for (int i = 0; i < n; ++i) s[i + 1] = s[i] + c[i];
auto solve = [&]() {
for (int i = 0; i < n; ++i) {
int cur = i, nxt = n + 1;
for (int j = 0; j < 5; ++j, cur = nxt) {
nxt = distance(begin(s), find(begin(s), end(s), s[cur] + phrase[j]));
if (nxt == n + 1) break;
if (j == 4) return i + 1;
}
}
return 0;
};
cout << solve() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int solve(vector<int> &a)
{
int N = a.size();
const int p[] = {5, 7, 5, 7, 7};
for (int i = 0; i < N; i++) {
bool poss = 1;
int q = i;
for (int j = 0; j < 5; j++) {
int sum = 0;
for (; q < N; ) {
sum += a[q++];
if (sum >= p[j]) break;
}
if (sum != p[j]) {
poss = 0;
break;
}
}
if (poss) {
return i + 1;
}
}
return -1;
}
int main()
{
int N;
while (cin >> N, N) {
vector<int> a(N);
string s;
for (int i = 0; i < N; i++) {
cin >> s;
a[i] = s.size();
}
cout << solve(a) << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
using namespace std;
#define FOR(k,m,n) for(int (k)=(m);(k)<(n);(k)++)
#define rep(i,n) FOR((i),0,(n))
typedef long long ll;
const int INF=1e9+7;
const int MAX_N=1e2;
int data[MAX_N];
int s[5]={5,7,5,7,7};
int main(){
int n;
while(cin>>n && n){
fill(data,data+MAX_N,0);
rep(i,n){
string str;
cin>>str;
data[i]=str.size();
}
int ans=0;
rep(i,n){
if(ans!=0)break;
int k=0;
rep(j,5){
int tmp=0;
while(tmp<s[j] && i+k<n){
tmp+=data[i+k++];
}
if(tmp!=s[j])break;
if(j==4)ans=i+1;
}
}
cout<<ans<<endl;
}
}
|
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
#include <utility>
#include <map>
using namespace std;
const double EPS = 1e-6;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return !EQ(a.X,b.X) ? a.X<b.X : a.Y+EPS<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
bool intersectSP(const L& s, const P &p){
return abs(cross(s[0]-p, s[1]-p))<EPS && dot(s[0]-p, s[1]-p)<EPS;
}
bool isParallel(const P &a, const P &b){
return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
return isParallel(a[1]-a[0], b[1]-b[0]);
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
int in_poly(const P &p, const VP &poly){
int n = poly.size();
int ret = -1;
for(int i=0; i<n; i++){
P a = poly[i]-p;
P b = poly[(i+1)%n]-p;
if(a.Y > b.Y) swap(a,b);
if(intersectSP(L(a,b), P(0,0))) return 0;
if(a.Y<=0 && b.Y>0 && cross(a,b)<0) ret = -ret;
}
return ret;
}
VP convex(VP v){
VP ret;
int n = v.size();
sort(v.begin(), v.end());
for(int i=0; i<n; i++){
while((int)ret.size()>1 && cross(ret.back()-ret[ret.size()-2], v[i]-ret.back()) < EPS){
ret.pop_back();
}
ret.push_back(v[i]);
}
int t = ret.size();
for(int i=n-2; i>=0; i--){
while((int)ret.size()>t && cross(ret.back()-ret[ret.size()-2], v[i]-ret.back()) < EPS){
ret.pop_back();
}
ret.push_back(v[i]);
}
if((int)ret.size() > 1) ret.pop_back();
return ret;
}
pair<vector<vector<double> >, VP> arrangementEX(const vector<L> &l, const VP &p){
vector<VP> cp(l.size());
VP plist = p;
for(int i=0; i<(int)l.size(); i++){
for(int j=i+1; j<(int)l.size(); j++){
if(!isParallel(l[i], l[j]) && intersectSS(l[i], l[j])){
P cpij = crosspointLL(l[i], l[j]);
cp[i].push_back(cpij);
cp[j].push_back(cpij);
plist.push_back(cpij);
}
}
for(int j=0; j<(int)p.size(); j++){
if(intersectSP(l[i], p[j])){
cp[i].push_back(p[j]);
}
}
cp[i].push_back(l[i][0]);
cp[i].push_back(l[i][1]);
plist.push_back(l[i][0]);
plist.push_back(l[i][1]);
sort(cp[i].begin(), cp[i].end());
cp[i].erase(unique(cp[i].begin(), cp[i].end()), cp[i].end());
}
sort(plist.begin(), plist.end());
plist.erase(unique(plist.begin(), plist.end()), plist.end());
int n = plist.size();
map<P, int> conv;
for(int i=0; i<n; i++){
conv[plist[i]] = i;
}
vector<vector<double> > adj(n, vector<double>(n, INF));
for(int i=0; i<(int)cp.size(); i++){
for(int j=0; j<(int)cp[i].size()-1; j++){
int jidx = conv[cp[i][j]];
int jp1idx = conv[cp[i][j+1]];
adj[jidx][jp1idx] = adj[jp1idx][jidx] = 0;
}
}
return make_pair(adj, plist);
}
int main(){
while(1){
//input
int n,m;
cin >> n >> m;
if(n == 0) break;
vector<VP> poly(n);
vector<double> h(n);
for(int i=0; i<n; i++){
int nv;
cin >> nv >> h[i];
poly[i].resize(nv);
for(int j=0; j<nv; j++){
int x,y;
cin >> x >> y;
poly[i][j] = P(x, y);
}
}
vector<L> lines(m);
for(int i=0; i<m; i++){
int xs,ys,xt,yt;
cin >> xs >> ys >> xt >> yt;
lines[i] = L(P(xs, ys), P(xt, yt));
}
double th,phi;
cin >> th >> phi;
th *= PI/180; phi *= PI/180;
P dir = P(cos(th+PI), sin(th+PI)) /tan(phi);
for(int i=0; i<n; i++){
VP tmp = poly[i];
P idir = dir *h[i];
for(int j=0; j<(int)poly[i].size(); j++){
tmp.push_back(poly[i][j] +idir);
}
poly[i] = convex(tmp);
}
VP sg(2);
int sx,sy,tx,ty;
cin >> sx >> sy >> tx >> ty;
sg[0] = P(sx, sy);
sg[1] = P(tx, ty);
//calc costs of edges
auto ret = arrangementEX(lines, sg);
auto &adj = ret.first;
VP &plist = ret.second;
int pn = plist.size();
int sidx = lower_bound(plist.begin(), plist.end(), sg[0]) -plist.begin();
int gidx = lower_bound(plist.begin(), plist.end(), sg[1]) -plist.begin();
for(int i=0; i<pn; i++){
for(int j=i+1;j<pn; j++){
if(adj[i][j] == INF) continue;
L e(plist[i], plist[j]);
VP cp(2);
cp[0] = e[0];
cp[1] = e[1];
for(int k=0; k<n; k++){
int vn = poly[k].size();
for(int l=0; l<vn; l++){
L edge(poly[k][l], poly[k][(l+1)%vn]);
if(!isParallel(e, edge) && intersectSS(e, edge)){
cp.push_back(crosspointLL(e, edge));
}
}
}
sort(cp.begin(), cp.end());
cp.erase(unique(cp.begin(), cp.end()), cp.end());
double cost = 0;
for(int k=0; k<(int)cp.size()-1; k++){
P mid = (cp[k] +cp[k+1]) /2.0;
bool in = false;
for(int l=0; l<n; l++){
if(in_poly(mid, poly[l]) >= 0){
in = true;
break;
}
}
if(!in){
cost += abs(cp[k+1] -cp[k]);
}
}
adj[i][j] = adj[j][i] = cost;
}
}
for(int k=0; k<pn; k++){
for(int i=0; i<pn; i++){
for(int j=0; j<pn; j++){
adj[i][j] = min(adj[i][j], adj[i][k] +adj[k][j]);
}
}
}
cout << fixed << setprecision(4);
cout << adj[sidx][gidx] << endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
static const double PI = acos(-1.0);
template<class T> T GCD( T x, T y ) { return x ? GCD(y%x,x) : y; }
struct Rational
{
Rational( long long num = 0, long long den = 1 ) : n(num), d(den)
{
if ( n && d ) {
long long gcd = GCD(n,d);
n /= gcd, d /= gcd;
} else if ( n ) {
n = 1;
} else if ( d ) {
d = 1;
}
}
Rational operator+( const Rational& rhs ) const
{
long long gcd = GCD( d, rhs.d );
return Rational( n*(rhs.d/gcd)+d/gcd*rhs.n, gcd*(d/gcd)*(rhs.d/gcd) );
}
Rational operator-( const Rational& rhs ) const
{
return Rational( n*rhs.d-d*rhs.n, d*rhs.d );
}
Rational operator*( const Rational& rhs ) const
{
Rational r1( n, rhs.d ), r2( rhs.n, d );
return Rational( r1.n*r2.n, r1.d*r2.d );
}
Rational operator/( const Rational& rhs ) const
{
return *this * Rational( rhs.d, rhs.n );
}
bool operator<( const Rational& rhs ) const
{
return n*rhs.d < rhs.n*d;
}
bool operator!=( const Rational& rhs ) const
{
return (rhs < *this) || (*this < rhs);
}
bool operator==( const Rational& rhs ) const
{
return !(rhs != *this);
}
bool operator<=( const Rational& rhs ) const
{
return !(rhs < *this);
}
Rational abs() const { return Rational(::abs(n),::abs(d)); }
double to_f() const { return 1.0*n/d; }
long long n;
long long d;
};
template<class T>
struct Vec2
{
Vec2( T _x, T _y ) : x(_x), y(_y) {}
double length() const { return sqrt(x*x + y*y); }
Vec2 operator+( const Vec2& rhs ) const { return Vec2(x+rhs.x, y+rhs.y); }
Vec2 operator-( const Vec2& rhs ) const { return Vec2(x-rhs.x, y-rhs.y); }
Vec2 operator*( T s ) const { return Vec2(x*s, y*s); }
T dot( const Vec2& rhs ) const { return x*rhs.x + y*rhs.y; }
T cross( const Vec2& rhs ) const { return x*rhs.y - y*rhs.x; }
bool operator<( const Vec2& rhs ) const
{
if ( x != rhs.x ) return x < rhs.x;
return y < rhs.y;
}
bool operator!=( const Vec2& rhs ) const
{
return (rhs < *this) || (*this < rhs);
}
bool operator==( const Vec2& rhs ) const
{
return !(rhs != *this);
}
T x;
T y;
};
typedef Vec2<double> VecD;
typedef Vec2<Rational> VecR;
template<class T>
T cross(const Vec2<T> &O, const Vec2<T> &A, const Vec2<T> &B)
{
return (A-O).cross(B-O);
}
template<class T>
void ConvexHull( const vector<Vec2<T> >& point, vector<size_t>& hull )
{
vector<pair<Vec2<T>,size_t> > P;
for ( int i = 0; i < (int)point.size(); i++ ) {
P.push_back( make_pair( point[i], i ) );
}
sort( P.begin(), P.end() );
vector<size_t> H(2*point.size());
int k = 0;
for ( int i = 0; i < (int)point.size(); i++ ) {
while ( k >= 2 && cross(P[H[k-2]].first, P[H[k-1]].first, P[i].first) <= 0 ) {
k--;
}
H[k++] = i;
}
int t = k+1;
for ( int i = point.size()-2; i >= 0; i-- ) {
while ( k >= t && cross(P[H[k-2]].first, P[H[k-1]].first, P[i].first) <= 0 ) {
k--;
}
H[k++] = i;
}
hull.resize(k);
for ( int i = 0; i < k; i++ ) {
hull[i] = P[H[i]].second;
}
}
template<class T>
bool IsIntSegments( const pair<Vec2<T>,Vec2<T> >& A, const pair<Vec2<T>,Vec2<T> >& B )
{
const Vec2<T>& A1 = A.first; const Vec2<T>& A2 = A.second;
const Vec2<T>& B1 = B.first; const Vec2<T>& B2 = B.second;
return ( cross(A1,A2,B1)*cross(A1,A2,B2) <= 0 && cross(B1,B2,A1)*cross(B1,B2,A2) <= 0 );
}
bool IsInsideOfConvexPolygon( const VecD& point, const vector<VecD>& poly )
{
const size_t n = poly.size() - 1;
VecD g = (poly[0] + poly[n/3] + poly[2*n/3]) * (1.0/3.0);
for ( size_t i = 0; i < poly.size()-1; i++ ) {
if ( IsIntSegments( make_pair(point,g), make_pair(poly[i],poly[i+1]) ) ) {
return false;
}
}
return true;
}
double SunshineLength( const VecD& A, const VecD& B, const vector<vector<VecD> >& shadow )
{
vector<double> param(1,0);
for ( size_t i = 0; i < shadow.size(); i++ ) {
for ( size_t j = 0; j < shadow[i].size()-1; j++ ) {
if ( !IsIntSegments( make_pair(A,B), make_pair(shadow[i][j], shadow[i][j+1]) ) ) {
continue;
}
VecD d = shadow[i][j+1] - shadow[i][j];
double d1 = fabs( cross( shadow[i][j], shadow[i][j+1], A ) );
double d2 = fabs( cross( shadow[i][j], shadow[i][j+1], B ) );
if ( d1 == 0 && d2 == 0 ) continue;
double t = d1 / (d1 + d2);
param.push_back( t );
}
}
param.push_back(1);
sort( param.begin(), param.end() );
double ratio = 1.0;
for ( size_t i = 0; i < param.size()-1; i++ ) {
double p = 0.5*(param[i]+param[i+1]);
VecD m = A + (B-A)*p;
for ( size_t j = 0; j < shadow.size(); j++ ) {
if ( IsInsideOfConvexPolygon( m, shadow[j] ) ) {
ratio -= param[i+1] - param[i];
break;
}
}
}
return ratio * sqrt((B-A).dot(B-A));
}
struct Node
{
Node() : cur(0,0), sum(0.0) {}
bool operator<( const Node& rhs ) const { return sum < rhs.sum; }
VecR cur;
vector<VecR> next;
vector<double> weight;
double sum;
};
int main()
{
int N, M;
while ( 1 ) {
cin >> N >> M;
if ( N==0 && M==0 ) break;
vector<double> height(N);
vector<vector<VecD> > vertices(N);
for ( int i = 0; i < N; i++ ) {
int NV;
cin >> NV >> height[i];
for ( int j = 0; j < NV; j++ ) {
double x, y;
cin >> x >> y;
vertices[i].push_back( VecD(x,y) );
}
}
vector<pair<VecR,VecR> > road;
for ( int i = 0; i < M; i++ ) {
int x0,y0,x1,y1;
cin >> x0 >> y0 >> x1 >> y1;
road.push_back( make_pair( VecR(x0,y0), VecR(x1,y1) ) );
}
double theta, phi;
cin >> theta >> phi;
phi = phi / 180 * PI;
theta = theta / 180 * PI;
int xs,ys,xt,yt;
cin >> xs >> ys >> xt >> yt;
VecR terms[2] = { VecR(xs,ys), VecR(xt,yt) };
vector<vector<VecD> > shadow(N);
for ( int i = 0; i < N; i++ ) {
vector<VecD> proj;
for ( size_t j = 0; j < vertices[i].size(); j++ ) {
proj.push_back( vertices[i][j] );
proj.push_back( vertices[i][j] - VecD(cos(theta),sin(theta))*(height[i]/tan(phi)) );
}
vector<size_t> hull;
ConvexHull( proj, hull );
for ( size_t j = 0; j < hull.size(); j++ ) {
shadow[i].push_back( proj[hull[j]] );
}
}
map<VecR,Node> g;
for ( size_t i = 0; i < road.size(); i++ ) {
vector<Rational> param;
for ( size_t j = 0; j < road.size(); j++ ) {
if ( i == j ) continue;
if ( !IsIntSegments(road[i], road[j]) ) continue;
Rational d1 = cross(road[j].first, road[j].second, road[i].first ).abs();
Rational d2 = cross(road[j].first, road[j].second, road[i].second ).abs();
if ( d1 == 0 && d2 == 0 ) continue;
Rational t = d1 / (d1 + d2);
param.push_back( t );
}
VecR d = road[i].second - road[i].first;
for ( int j = 0; j < 2; j++ ) {
VecR ds = terms[j] - road[i].first;
if ( d.cross(ds) == 0 ) {
Rational t = d.dot(ds) / d.dot(d);
if ( Rational(0) <= t && t <= 1 ) {
param.push_back(t);
}
}
}
sort( param.begin(), param.end() );
for ( size_t j = 1; j < param.size(); j++ ) {
if ( param[j-1] < param[j] ) {
VecR v1 = road[i].first + d*param[j-1];
VecR v2 = road[i].first + d*param[j];
double w = SunshineLength(
VecD(v1.x.to_f(),v1.y.to_f()), VecD(v2.x.to_f(),v2.y.to_f()), shadow );
g[v1].cur = v1;
g[v1].next.push_back(v2);
g[v1].weight.push_back(w);
g[v1].sum = (v1==terms[0] ? 0.0 : HUGE_VAL);
g[v2].cur = v2;
g[v2].next.push_back(v1);
g[v2].weight.push_back(w);
g[v2].sum = (v2==terms[0] ? 0.0 : HUGE_VAL);
}
}
}
multiset<Node> s;
s.insert( g[terms[0]] );
set<VecR> fixed;
while ( !s.empty() ) {
Node c = *s.begin();
s.erase( s.begin() );
if ( !fixed.insert( c.cur ).second ) continue;
if ( c.cur == terms[1] ) {
printf( "%.10f\n", c.sum );
break;
}
for ( size_t i = 0; i < c.next.size(); i++ ) {
Node n = g[c.next[i]];
if ( n.sum > c.sum + c.weight[i] && fixed.count(n.cur) == 0 ) {
n.sum = c.sum + c.weight[i];
s.insert( n );
}
}
}
}
return 0;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-7)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
using namespace std;
const bool debug = false; // DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG
inline double toRad(double theta){
return theta * M_PI / 180.0;
}
// x >= y
bool GTE(double x, double y){ return equals(x,y) || x > y; }
// x > y
bool GT(double x, double y){ return !equals(x,y) && x > y; }
// x < y
bool LT(double x, double y){ return !equals(x,y) && x < y; }
// x <= y
bool LTE(double x, double y){ return equals(x,y) || x < y; }
// -- Library 2d -- BEGIN ----------------------------------------
class Point{
public:
double x,y;
Point(double x = 0,double y = 0): x(x),y(y){}
Point operator + (Point p){return Point(x+p.x,y+p.y);}
Point operator - (Point p){return Point(x-p.x,y-p.y);}
Point operator * (double a){return Point(a*x,a*y);}
Point operator / (double a){return Point(x/a,y/a);}
Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }
bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }
bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }
};
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
bool operator < (const Segment& s) const { return ( p2 == s.p2 ) ? p1 < s.p1 : p2 < s.p2; }
bool operator == (const Segment& s) const { return ( s.p1 == p1 && s.p2 == p2 ) || ( s.p1 == p2 && s.p2 == p1 ); }
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream& operator << (ostream& os,const Point& a){ return os << "(" << a.x << "," << a.y << ")"; }
ostream& operator << (ostream& os,const Segment& a){ return os << "( " << a.p1 << " , " << a.p2 << " )"; }
double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }
//rad ????§???????????????¢?????§?????????????????¨
Point rotate(Point a,double rad){ return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y); }
// a => prev, b => cur, c=> next
// prev ?????? cur ????????£??? next ????????????????§????????±???????
double getArg(Point a,Point b,Point c){
double arg1 = atan2(b.y-a.y,b.x-a.x);
double arg2 = atan2(c.y-b.y,c.x-b.x);
double arg = fabs( arg1 - arg2 );
while( arg > M_PI ) arg -= 2.0 * M_PI;
return fabs(arg);
}
int ccw(Point p0,Point p1,Point p2){
Point a = p1-p0;
Point b = p2-p0;
if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
if(cross(a,b) < -EPS)return CLOCKWISE;
if(dot(a,b) < -EPS)return ONLINE_BACK;
if(norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2-l.p1, m.p2-m.p1)) > EPS || // non-parallel
abs(cross(l.p2-l.p1, m.p1-l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2-l.p1, s.p1-l.p1)* // s[0] is left of l
cross(l.p2-l.p1, s.p2-l.p1) < EPS; // s[1] is right of l
}
bool intersectLP(Line l,Point p) {
return abs(cross(l.p2-p, l.p1-p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality
}
Point projection(Line l,Point p) {
double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
return l.p1 + (l.p1-l.p2)*t;
}
Point reflection(Line l,Point p) {
return p + (projection(l, p) - p) * 2;
}
double distanceLP(Line l, Point p) {
return abs(p - projection(l, p));
}
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l,Line m){
double A = cross(l.p2-l.p1,m.p2-m.p1);
double B = cross(l.p2-l.p1,l.p2-m.p1);
if(abs(A) < EPS && abs(B) < EPS){
vector<Point> vec;
vec.push_back(l.p1),vec.push_back(l.p2),vec.push_back(m.p1),vec.push_back(m.p2);
sort(vec.begin(),vec.end());
assert(vec[1] == vec[2]); //???????????°??????????????????
return vec[1];
//return m.p1;
}
if(abs(A) < EPS)assert(false);
return m.p1 + (m.p2-m.p1)*(B/A);
}
struct Edge {
int from,to;
double cost;
Edge(int from=0,int to=0,double cost=0):from(from),to(to),cost(cost){}
bool operator < (const Edge& a)const { return !equals(cost,a.cost) && cost < a.cost; }
};
vector<vector<Edge> > segmentArrangement(vector<Segment> vs,vector<Point> &ps) {
/*
???????????????????????????
????????§???????????????????????????ps????????????
*/
rep(i,(int)vs.size())
REP(j,i+1,(int)vs.size())
if(intersectSS(vs[i],vs[j]))
ps.push_back(Point(crosspoint(vs[i],vs[j])));
sort(ps.begin(),ps.end());
ps.erase(unique(ps.begin(),ps.end()),ps.end());
vector<vector<Edge> > ret(ps.size());
for(int i=0;i<(int)vs.size();i++){
vector<pair<double,int> > list;
rep(j,(int)ps.size()) if(intersectSP(vs[i],ps[j]))list.push_back(pair<double,int>(norm(vs[i].p1-ps[j]),j));
sort(list.begin(),list.end());
for(int j=0;j+1<(int)list.size();++j) {
int from = list[j].second, to = list[j+1].second;
double cost = abs(ps[from]-ps[to]);
ret[from].push_back(Edge(from,to,cost));
ret[to].push_back(Edge(to,from,cost));
}
}
return ret;
}
//cross product of pq and pr
double cross3p(Point p,Point q,Point r) { return (r.x-q.x) * (p.y -q.y) - (r.y - q.y) * (p.x - q.x); }
//returns true if point r is on the same line as the line pq
bool collinear(Point p,Point q,Point r) { return fabs(cross3p(p,q,r)) < EPS; }
//returns true if point t is on the left side of line pq
bool ccwtest(Point p,Point q,Point r){
return cross3p(p,q,r) > 0; //can be modified to accept collinear points
}
bool onSegment(Point p,Point q,Point r){
return collinear(p,q,r) && equals(sqrt(pow(p.x-r.x,2)+pow(p.y-r.y,2)) + sqrt(pow(r.x-q.x,2) + pow(r.y-q.y,2) ),sqrt(pow(p.x-q.x,2)+pow(p.y-q.y,2)) ) ;
}
bool isConvex(vector<Point> p) {
int sz = (int)p.size();
if(sz < 3)return false;//boundary case, we treat a point or a line as not convex
bool isLeft = ccwtest(p[0],p[1],p[2]);
for(int i=1; i<(int)p.size();i++)
if(ccwtest(p[i],p[(i+1)%sz],p[(i+2)%sz]) != isLeft) return false;
return true;
}
double angle(Point a,Point b,Point c) {
double ux = b.x - a.x, uy = b.y - a.y;
double vx = c.x - a.x, vy = c.y - a.y;
return acos((ux*vx + uy*vy)/sqrt((ux*ux + uy*uy) * (vx*vx + vy*vy)));
}
//????§???¢poly?????????????????????????????????p????????¨??????????????????????????????
bool inPolygon(Polygon poly,Point p){
if((int)poly.size() == 0)return false;
rep(i,(int)poly.size()) if(onSegment(poly[i],poly[(i+1)%poly.size()],p))return true;
double sum = 0;
for(int i=0; i < (int)poly.size() ;i++) {
if( equals(cross(poly[i]-p,poly[(i+1)%poly.size()]-p),0.0) ) continue; // ????????????????????¨angle???nan?????????sum???nan??????????????¬
if( cross3p(p,poly[i],poly[(i+1)%poly.size()]) < 0 ) sum -= angle(p,poly[i],poly[(i+1)%poly.size()]);
else sum += angle(p,poly[i],poly[(i+1)%poly.size()]);
}
// ?????????????????????????????????????????¨?????????????????§??\?????????????????????
const double eps = 1e-5;
return (fabs(sum - 2*M_PI) < eps || fabs(sum + 2*M_PI) < eps);
}
bool inPolygon(const Polygon &poly,Segment seg){
vector<Point> vp;
vp.push_back(seg.p1);
vp.push_back(seg.p2);
rep(i,(int)poly.size()) {
Segment edge = Segment(poly[i],poly[(i+1)%(int)poly.size()]);
if( equals(cross(seg.p1-seg.p2,edge.p1-edge.p2),0.0) ) {
if( onSegment(seg.p1,seg.p2,edge.p1) ) vp.push_back(edge.p1);
if( onSegment(seg.p1,seg.p2,edge.p2) ) vp.push_back(edge.p2);
} else {
if( intersectSS(seg,edge) ) vp.push_back(crosspoint(seg,edge));
}
}
sort(vp.begin(),vp.end());
vp.erase(unique(vp.begin(),vp.end()),vp.end());
rep(i,(int)vp.size()-1) {
Point middle_point = ( vp[i] + vp[i+1] ) / 2.0;
if( !inPolygon(poly,middle_point) ) return false;
}
return true;
}
Polygon andrewScan(Polygon s)
{
Polygon u,l;
if((int)s.size() < 3)return s;
sort(s.begin(),s.end());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size()-1]);
l.push_back(s[s.size()-2]);
for(int i=2;i<(int)s.size();i++)
{
for(int n=(int)u.size();n >= 2 && ccw(u[n-2],u[n-1],s[i]) != CLOCKWISE; n--)
u.pop_back();
u.push_back(s[i]);
}
for(int i=(int)s.size()-3; i>=0 ; i--)
{
for(int n=(int)l.size(); n >= 2 && ccw(l[n-2],l[n-1],s[i]) != CLOCKWISE; n--)
l.pop_back();
l.push_back(s[i]);
}
reverse(l.begin(),l.end());
for(int i = (int)u.size()-2; i >= 1; i--) l.push_back(u[i]);
return l;
}
// -- Library 2d -- END ----------------------------------------
struct Data {
int cur;
double v;
bool operator < (const Data &data) const {
//return v > data.v;
return LT(data.v,v); // data.v < v
}
};
double dijkstra(vector<vector<Edge>> &G,int s,int t) {
int V = G.size();
vector<double> mini(V,1e8);
priority_queue<Data> Q;
Q.push((Data){s,0});
mini[s] = 0;
while( !Q.empty() ) {
Data data = Q.top(); Q.pop();
rep(i,(int)G[data.cur].size()) {
Edge &e = G[data.cur][i];
if( LT(data.v+e.cost,mini[e.to]) ) {
mini[e.to] = data.v + e.cost;
Q.push((Data){e.to,mini[e.to]});
}
}
}
assert( !equals(mini[t],1e8) );
return mini[t];
}
inline bool is_parallel(Segment s,Segment t) { return equals(cross(s.p1-s.p2,t.p1-t.p2),0.0); }
const double rho = 1e5;
Polygon calc_shadow(Polygon &poly,double H,double theta,double phi) {
assert( poly.size() >= 3 );
assert( !( is_parallel(Segment(poly[0],poly[1]),Segment(poly[1],poly[2])) ) );
theta = toRad(theta);
phi = toRad(phi);
if( debug ) {
cout << "theta = " << theta << " and phi = " << phi << endl;
}
Polygon shadow_poly;
rep(i,(int)poly.size()) {
double r = H / tan(phi);
Vector v = Vector(r*cos(theta),r*sin(theta));
shadow_poly.push_back(poly[i]-v);
}
rep(i,(int)poly.size()) shadow_poly.push_back(poly[i]);
return andrewScan(shadow_poly);
}
void compute(vector<double> &H,vector<Polygon> &polies,vector<Segment> &segs,double theta,double phi,Point &s,Point &t) {
// ??±?????°??????????§????
vector<Polygon> shadow_polies;
rep(i,(int)polies.size()) {
shadow_polies.push_back(calc_shadow(polies[i],H[i],theta,phi));
if( debug ) {
puts("");
cout << i << "-th polygon (MINE)" << endl;
rep(j,(int)shadow_polies[i].size()) {
cout << shadow_polies[i][j] << endl;
}
puts("");
}
}
if( debug ) {
puts("");
cout << "--- graph construction was finished! ---" << endl;
puts("");
}
// ????????????
vector<Point> ps;
rep(i,(int)segs.size()) {
ps.push_back(segs[i].p1);
ps.push_back(segs[i].p2);
}
ps.push_back(s);
ps.push_back(t);
rep(i,(int)shadow_polies.size()) {
int V = shadow_polies[i].size();
rep(j,V) {
Segment seg = Segment(shadow_polies[i][j],shadow_polies[i][(j+1)%V]);
rep(k,(int)segs.size()) {
if( intersectSS(seg,segs[k]) ) {
ps.push_back(crosspoint(seg,segs[k]));
}
}
}
}
if( debug ) {
puts("");
cout << "--- enumeration was finished! ---" << endl;
puts("");
}
// ??°???????§????
vector<vector<Edge>> G = segmentArrangement(segs,ps);
assert( G.size() == ps.size() );
if( debug ) {
puts("");
cout << "--- arrangement was finished! ---" << endl;
puts("");
}
// ???????????? (????????°????????±???????????????????????????0)
rep(i,(int)G.size()) {
rep(j,(int)G[i].size()) {
Edge &e = G[i][j];
Point mp = (ps[e.from]+ps[e.to])/2.0;
bool in_shadow = false;
rep(k,(int)shadow_polies.size()) {
if( inPolygon(shadow_polies[k],mp) ) {
in_shadow = true;
break;
}
}
if( in_shadow ) {
e.cost = 0;
}
}
}
if( debug ) {
puts("");
cout << "--- weighting was finished! ---" << endl;
puts("");
}
// dijkstra
int sp=-1,ep=-1;
rep(i,(int)ps.size()) {
if( ps[i] == s ) sp = i;
if( ps[i] == t ) ep = i;
}
assert( sp != -1 );
assert( ep != -1 );
printf("%.10f\n",dijkstra(G,sp,ep));
}
int main() {
int N,M;
while( cin >> N >> M, N|M ) {
vector<double> H(N);
vector<Polygon> polies(N);
rep(i,N) {
int V;
cin >> V >> H[i];
polies[i].resize(V);
rep(j,V) cin >> polies[i][j].x >> polies[i][j].y;
}
vector<Segment> segs(M);
rep(i,M) cin >> segs[i].p1.x >> segs[i].p1.y >> segs[i].p2.x >> segs[i].p2.y;
double theta,phi;
cin >> theta >> phi;
Point s,t;
cin >> s.x >> s.y;
cin >> t.x >> t.y;
rep(i,N) {
int V = polies[i].size();
rep(j,V) {
Segment seg = Segment(polies[i][j],polies[i][(j+1)%V]);
rep(k,M) {
assert( !intersectSS(seg,segs[k]) );
}
}
}
compute(H,polies,segs,theta,phi,s,t);
}
return 0;
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-7)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
using namespace std;
const bool debug = false; // DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG - DEBUG
inline double toRad(double theta){
return theta * M_PI / 180.0;
}
// x >= y
bool GTE(double x, double y){ return equals(x,y) || x > y; }
// x > y
bool GT(double x, double y){ return !equals(x,y) && x > y; }
// x < y
bool LT(double x, double y){ return !equals(x,y) && x < y; }
// x <= y
bool LTE(double x, double y){ return equals(x,y) || x < y; }
// -- Library 2d -- BEGIN ----------------------------------------
class Point{
public:
double x,y;
Point(double x = 0,double y = 0): x(x),y(y){}
Point operator + (Point p){return Point(x+p.x,y+p.y);}
Point operator - (Point p){return Point(x-p.x,y-p.y);}
Point operator * (double a){return Point(a*x,a*y);}
Point operator / (double a){return Point(x/a,y/a);}
Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }
bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }
bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }
};
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
bool operator < (const Segment& s) const { return ( p2 == s.p2 ) ? p1 < s.p1 : p2 < s.p2; }
bool operator == (const Segment& s) const { return ( s.p1 == p1 && s.p2 == p2 ) || ( s.p1 == p2 && s.p2 == p1 ); }
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream& operator << (ostream& os,const Point& a){ return os << "(" << a.x << "," << a.y << ")"; }
ostream& operator << (ostream& os,const Segment& a){ return os << "( " << a.p1 << " , " << a.p2 << " )"; }
double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }
//rad ????§???????????????¢?????§?????????????????¨
Point rotate(Point a,double rad){ return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y); }
// a => prev, b => cur, c=> next
// prev ?????? cur ????????£??? next ????????????????§????????±???????
double getArg(Point a,Point b,Point c){
double arg1 = atan2(b.y-a.y,b.x-a.x);
double arg2 = atan2(c.y-b.y,c.x-b.x);
double arg = fabs( arg1 - arg2 );
while( arg > M_PI ) arg -= 2.0 * M_PI;
return fabs(arg);
}
int ccw(Point p0,Point p1,Point p2){
Point a = p1-p0;
Point b = p2-p0;
if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
if(cross(a,b) < -EPS)return CLOCKWISE;
if(dot(a,b) < -EPS)return ONLINE_BACK;
if(norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2-l.p1, m.p2-m.p1)) > EPS || // non-parallel
abs(cross(l.p2-l.p1, m.p1-l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2-l.p1, s.p1-l.p1)* // s[0] is left of l
cross(l.p2-l.p1, s.p2-l.p1) < EPS; // s[1] is right of l
}
bool intersectLP(Line l,Point p) {
return abs(cross(l.p2-p, l.p1-p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality
}
Point projection(Line l,Point p) {
double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
return l.p1 + (l.p1-l.p2)*t;
}
Point reflection(Line l,Point p) {
return p + (projection(l, p) - p) * 2;
}
double distanceLP(Line l, Point p) {
return abs(p - projection(l, p));
}
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l,Line m){
double A = cross(l.p2-l.p1,m.p2-m.p1);
double B = cross(l.p2-l.p1,l.p2-m.p1);
if(abs(A) < EPS && abs(B) < EPS){
vector<Point> vec;
vec.push_back(l.p1),vec.push_back(l.p2),vec.push_back(m.p1),vec.push_back(m.p2);
sort(vec.begin(),vec.end());
assert(vec[1] == vec[2]); //???????????°??????????????????
return vec[1];
//return m.p1;
}
if(abs(A) < EPS)assert(false);
return m.p1 + (m.p2-m.p1)*(B/A);
}
struct Edge {
int from,to;
double cost;
Edge(int from=0,int to=0,double cost=0):from(from),to(to),cost(cost){}
bool operator < (const Edge& a)const { return !equals(cost,a.cost) && cost < a.cost; }
};
vector<vector<Edge> > segmentArrangement(vector<Segment> vs,vector<Point> &ps) {
/*
???????????????????????????
????????§???????????????????????????ps????????????
*/
rep(i,(int)vs.size())
REP(j,i+1,(int)vs.size())
if(intersectSS(vs[i],vs[j]))
ps.push_back(Point(crosspoint(vs[i],vs[j])));
sort(ps.begin(),ps.end());
ps.erase(unique(ps.begin(),ps.end()),ps.end());
vector<vector<Edge> > ret(ps.size());
for(int i=0;i<(int)vs.size();i++){
vector<pair<double,int> > list;
rep(j,(int)ps.size()) if(intersectSP(vs[i],ps[j]))list.push_back(pair<double,int>(norm(vs[i].p1-ps[j]),j));
sort(list.begin(),list.end());
for(int j=0;j+1<(int)list.size();++j) {
int from = list[j].second, to = list[j+1].second;
double cost = abs(ps[from]-ps[to]);
ret[from].push_back(Edge(from,to,cost));
ret[to].push_back(Edge(to,from,cost));
}
}
return ret;
}
//cross product of pq and pr
double cross3p(Point p,Point q,Point r) { return (r.x-q.x) * (p.y -q.y) - (r.y - q.y) * (p.x - q.x); }
//returns true if point r is on the same line as the line pq
bool collinear(Point p,Point q,Point r) { return fabs(cross3p(p,q,r)) < EPS; }
//returns true if point t is on the left side of line pq
bool ccwtest(Point p,Point q,Point r){
return cross3p(p,q,r) > 0; //can be modified to accept collinear points
}
bool onSegment(Point p,Point q,Point r){
return collinear(p,q,r) && equals(sqrt(pow(p.x-r.x,2)+pow(p.y-r.y,2)) + sqrt(pow(r.x-q.x,2) + pow(r.y-q.y,2) ),sqrt(pow(p.x-q.x,2)+pow(p.y-q.y,2)) ) ;
}
bool isConvex(vector<Point> p) {
int sz = (int)p.size();
if(sz < 3)return false;//boundary case, we treat a point or a line as not convex
bool isLeft = ccwtest(p[0],p[1],p[2]);
for(int i=1; i<(int)p.size();i++)
if(ccwtest(p[i],p[(i+1)%sz],p[(i+2)%sz]) != isLeft) return false;
return true;
}
double angle(Point a,Point b,Point c) {
double ux = b.x - a.x, uy = b.y - a.y;
double vx = c.x - a.x, vy = c.y - a.y;
return acos((ux*vx + uy*vy)/sqrt((ux*ux + uy*uy) * (vx*vx + vy*vy)));
}
//????§???¢poly?????????????????????????????????p????????¨??????????????????????????????
bool inPolygon(Polygon poly,Point p){
if((int)poly.size() == 0)return false;
rep(i,(int)poly.size()) if(onSegment(poly[i],poly[(i+1)%poly.size()],p))return true;
double sum = 0;
for(int i=0; i < (int)poly.size() ;i++) {
if( equals(cross(poly[i]-p,poly[(i+1)%poly.size()]-p),0.0) ) continue; // ????????????????????¨angle???nan?????????sum???nan??????????????¬
if( cross3p(p,poly[i],poly[(i+1)%poly.size()]) < 0 ) sum -= angle(p,poly[i],poly[(i+1)%poly.size()]);
else sum += angle(p,poly[i],poly[(i+1)%poly.size()]);
}
// ?????????????????????????????????????????¨?????????????????§??\?????????????????????
const double eps = 1e-5;
return (fabs(sum - 2*M_PI) < eps || fabs(sum + 2*M_PI) < eps);
}
bool inPolygon(const Polygon &poly,Segment seg){
vector<Point> vp;
vp.push_back(seg.p1);
vp.push_back(seg.p2);
rep(i,(int)poly.size()) {
Segment edge = Segment(poly[i],poly[(i+1)%(int)poly.size()]);
if( equals(cross(seg.p1-seg.p2,edge.p1-edge.p2),0.0) ) {
if( onSegment(seg.p1,seg.p2,edge.p1) ) vp.push_back(edge.p1);
if( onSegment(seg.p1,seg.p2,edge.p2) ) vp.push_back(edge.p2);
} else {
if( intersectSS(seg,edge) ) vp.push_back(crosspoint(seg,edge));
}
}
sort(vp.begin(),vp.end());
vp.erase(unique(vp.begin(),vp.end()),vp.end());
rep(i,(int)vp.size()-1) {
Point middle_point = ( vp[i] + vp[i+1] ) / 2.0;
if( !inPolygon(poly,middle_point) ) return false;
}
return true;
}
Polygon andrewScan(Polygon s)
{
Polygon u,l;
if((int)s.size() < 3)return s;
sort(s.begin(),s.end());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size()-1]);
l.push_back(s[s.size()-2]);
for(int i=2;i<(int)s.size();i++)
{
for(int n=(int)u.size();n >= 2 && ccw(u[n-2],u[n-1],s[i]) != CLOCKWISE; n--)
u.pop_back();
u.push_back(s[i]);
}
for(int i=(int)s.size()-3; i>=0 ; i--)
{
for(int n=(int)l.size(); n >= 2 && ccw(l[n-2],l[n-1],s[i]) != CLOCKWISE; n--)
l.pop_back();
l.push_back(s[i]);
}
reverse(l.begin(),l.end());
for(int i = (int)u.size()-2; i >= 1; i--) l.push_back(u[i]);
return l;
}
// -- Library 2d -- END ----------------------------------------
struct Data {
int cur;
double v;
bool operator < (const Data &data) const {
//return v > data.v;
return LT(data.v,v); // data.v < v
}
};
double dijkstra(vector<vector<Edge>> &G,int s,int t) {
int V = G.size();
vector<double> mini(V,1e8);
priority_queue<Data> Q;
Q.push((Data){s,0});
mini[s] = 0;
while( !Q.empty() ) {
Data data = Q.top(); Q.pop();
rep(i,(int)G[data.cur].size()) {
Edge &e = G[data.cur][i];
if( LT(data.v+e.cost,mini[e.to]) ) {
mini[e.to] = data.v + e.cost;
Q.push((Data){e.to,mini[e.to]});
}
}
}
assert( !equals(mini[t],1e8) );
return mini[t];
}
inline bool is_parallel(Segment s,Segment t) { return equals(cross(s.p1-s.p2,t.p1-t.p2),0.0); }
const double rho = 1e5;
Polygon calc_shadow(Polygon &poly,double H,double theta,double phi) {
assert( poly.size() >= 3 );
assert( !( is_parallel(Segment(poly[0],poly[1]),Segment(poly[1],poly[2])) ) );
theta = toRad(theta);
phi = toRad(phi);
if( debug ) {
cout << "theta = " << theta << " and phi = " << phi << endl;
}
Polygon shadow_poly;
rep(i,(int)poly.size()) {
double r = H / tan(phi);
Vector v = Vector(r*cos(theta),r*sin(theta));
shadow_poly.push_back(poly[i]-v);
}
rep(i,(int)poly.size()) shadow_poly.push_back(poly[i]);
return andrewScan(shadow_poly);
}
void compute(vector<double> &H,vector<Polygon> &polies,vector<Segment> &segs,double theta,double phi,Point &s,Point &t) {
// ??±?????°??????????§????
vector<Polygon> shadow_polies;
rep(i,(int)polies.size()) {
shadow_polies.push_back(calc_shadow(polies[i],H[i],theta,phi));
if( debug ) {
puts("");
cout << i << "-th polygon (MINE)" << endl;
rep(j,(int)shadow_polies[i].size()) {
cout << shadow_polies[i][j] << endl;
}
puts("");
}
}
if( debug ) {
puts("");
cout << "--- graph construction was finished! ---" << endl;
puts("");
}
// ????????????
vector<Point> ps;
rep(i,(int)segs.size()) {
ps.push_back(segs[i].p1);
ps.push_back(segs[i].p2);
}
ps.push_back(s);
ps.push_back(t);
rep(i,(int)shadow_polies.size()) {
int V = shadow_polies[i].size();
rep(j,V) {
Segment seg = Segment(shadow_polies[i][j],shadow_polies[i][(j+1)%V]);
rep(k,(int)segs.size()) {
if( intersectSS(seg,segs[k]) ) {
ps.push_back(crosspoint(seg,segs[k]));
}
}
}
}
if( debug ) {
puts("");
cout << "--- enumeration was finished! ---" << endl;
puts("");
}
// ??°???????§????
vector<vector<Edge>> G = segmentArrangement(segs,ps);
assert( G.size() == ps.size() );
if( debug ) {
puts("");
cout << "--- arrangement was finished! ---" << endl;
puts("");
}
// ???????????? (????????°????????±???????????????????????????0)
rep(i,(int)G.size()) {
rep(j,(int)G[i].size()) {
Edge &e = G[i][j];
Point mp = (ps[e.from]+ps[e.to])/2.0;
bool in_shadow = false;
rep(k,(int)shadow_polies.size()) {
if( inPolygon(shadow_polies[k],mp) ) {
in_shadow = true;
break;
}
}
if( in_shadow ) {
e.cost = 0;
}
}
}
if( debug ) {
puts("");
cout << "--- weighting was finished! ---" << endl;
puts("");
}
// dijkstra
int sp=-1,ep=-1;
rep(i,(int)ps.size()) {
if( ps[i] == s ) sp = i;
if( ps[i] == t ) ep = i;
}
assert( sp != -1 );
assert( ep != -1 );
printf("%.10f\n",dijkstra(G,sp,ep));
}
int main() {
int N,M;
while( cin >> N >> M, N|M ) {
vector<double> H(N);
vector<Polygon> polies(N);
rep(i,N) {
int V;
cin >> V >> H[i];
polies[i].resize(V);
rep(j,V) cin >> polies[i][j].x >> polies[i][j].y;
}
vector<Segment> segs(M);
rep(i,M) cin >> segs[i].p1.x >> segs[i].p1.y >> segs[i].p2.x >> segs[i].p2.y;
double theta,phi;
cin >> theta >> phi;
Point s,t;
cin >> s.x >> s.y;
cin >> t.x >> t.y;
compute(H,polies,segs,theta,phi,s,t);
}
return 0;
}
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-10;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt"
int K, R, L;
ld P;
ld E;
ld T;
long long int atime(const long long int l, const long long int r) {
if (l > LLONG_MAX / r) {
return LLONG_MAX;
}
else {
return l*r;
}
}
long long int powint(long long int a, long long int b) {
if (!b)return 1;
else {
return atime(a, powint(a, b - 1));
}
}
long long int aplus(const long long int l, const long long int r) {
if (l > LLONG_MAX / 3 || R > LLONG_MAX)return LLONG_MAX;
else return l + r;
}
//ld getans(const ld amin, const ld amax,const int rest,const ld per) {
// if (!rest||per<4e-8) {
// return abs((amin + amax) / 2 - T) < E+eps;
// }
// if (amin > E + T+eps)return 0;
// if (amax < T-E - eps)return 0;
// if (amin > T - E - eps&&T + E + eps < amax)return 1;
// ld amid = (amin + amax) / 2;
// if (amid > T-eps) {
// return getans(amin, amid,rest-1,per*(1-P))*(1-P) + getans(amid, amax,rest-1,per*P)*P;
// }
// else {
// return getans(amin, amid, rest - 1,per*P)*P + getans(amid, amax, rest - 1,per*(1-P))*(1 - P);
// }
//}
void getans(const vector<long long int>& sums,const vector<long long int>&tickets, const int now, long long int &ans,const long long int rest) {
if (now == tickets.size()) {
ans = min(ans, rest);
return;
}
if (ans < rest - sums[now])return;
if (rest >= tickets[now]) {
getans(sums, tickets, now + 1, ans, rest - tickets[now]);
}
else {
ans = min(ans, tickets[now] - rest);
}
getans(sums, tickets, now + 1, ans, rest);
}
int main() {
//cin >> K >> R >> L;
//cin >> P >> E >> T;
//ld ans = getans(R, L, K,1);
//cout << setprecision(22) << fixed << ans << endl;
//return 0;
long long int N, M, A, B, P, Q; cin >> N >> M >> A >> B >> P >> Q;
if (A > B) {
swap(A, B);
swap(P, Q);
}
assert(A <= B);
if (A == 1 && B == 1) {
long long int ticdis = P + Q;
if (atime(ticdis,N) <= M) {
cout << M - atime(ticdis, N) << endl;
}
else {
cout << min(ticdis-M%ticdis,M%ticdis) << endl;
}
}
else {
vector<long long int>tickets;
long long int ans = M;
for (int k = 0; k < N; ++k) {
long long int tic =aplus( atime(P, powint(A, k)), atime(Q, powint(B, k)));
if (tic > M) {
ans = min(ans, tic - M);
break;
}
else {
tickets.emplace_back(tic);
}
}
reverse(tickets.begin(), tickets.end());
vector<long long int>sums(tickets);
for (int i = sums.size()-1; i >0; --i) {
sums[i - 1] += sums[i];
}
getans(sums, tickets, 0, ans, M);
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define N 41
using namespace std;
typedef long long ll;
ll n,m,a,b,p,q,d[N];
vector<ll> v[2],x[2];
int main(){
cin>>n>>m>>a>>b>>p>>q;
ll ans=m;
if(a==1&&b==1){
ll ti=min(n,m/(p+q));
ans=min(ans,min(m-ti*(p+q),abs(min(ti+1,n)*(p+q)-m)));
}
ll A=1,B=1;
for(int i=0;i<min((ll)N,n);i++){
d[i]=p*A+q*B;
if(i<min((ll)N,n)/2)v[0].push_back(d[i]);
else v[1].push_back(d[i]);
if(d[i]>m)break;
A*=a,B*=b;
}
for(int i=0;i<2;i++){
v[i].push_back(0);
for(int j=0;j<(1<<v[i].size());j++){
ll sum=0;
for(int k=0;k<v[i].size();k++){
if(!(j&(1<<k)))continue;
sum+=v[i][k];
}
x[i].push_back(sum);
}
sort(x[i].begin(),x[i].end());
}
for(int i=0;i<x[0].size();i++){
ll search=m-x[0][i];
vector<ll>::iterator r=lower_bound(x[1].begin(),x[1].end(),search);
if(r!=x[1].end())ans=min(ans,(*r)-search);
if(r!=x[1].begin())ans=min(ans,search-(*(r-1)));
}
cout<<ans<<endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.