模拟+链表+DP


  Orz AK爷faebdc

A

  Growin要跟全部的n个人握手共2n杯香槟,再加上每对关系的两杯香槟,直接统计邻接矩阵中1的个数,再加2n就是answer

 //BestCoder 42 A
#include<vector>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define rep(i,n) for(int i=0;i<n;++i)
#define F(i,j,n) for(int i=j;i<=n;++i)
#define D(i,j,n) for(int i=j;i>=n;--i)
#define pb push_back
using namespace std;
inline int getint(){
int v=,sign=; char ch=getchar();
while(ch<''||ch>''){ if (ch=='-') sign=-; ch=getchar();}
while(ch>=''&&ch<=''){ v=v*+ch-''; ch=getchar();}
return v*sign;
}
const int N=1e5+,INF=~0u>>;
typedef long long LL;
/******************tamplate*********************/
int n,a[][];
int main(){
#ifndef ONLINE_JUDGE
freopen("A.in","r",stdin);
freopen("A.out","w",stdout);
#endif
while(scanf("%d",&n)!=EOF){
memset(a,,sizeof a);
LL cnt=;
F(i,,n) F(j,,n){
a[i][j]=getint();
if (a[i][j]) cnt++;
}
printf("%lld\n",cnt+*n);
}
return ;
}

B

  我一开始写了个以height为第一关键字,下标为第二关键字的set……每次直接lower_bound……然而TLE了aaarticlea/jpeg;base64,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" alt="" />

  后来改了改离散化+链表模拟……结果FST了aaarticlea/gif;base64,R0lGODlhQgBCANUAAP////f39+z39+/v7+Dv8+bm5tbn7ube3t7e3sXg4N7W1rre49bW1s7Nza7W2cXFxZXO16PHyb6+vby1tYi/y7Wwraympm+1vaWcnJycnHmjq0yqspqUlJSMjFmcnIiMjIqEhH57e3Nzc2tra4xjY5xaWmNjY61KUlJKSs0jQjEpKSEZGf4BAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFCgAsACwAAAAAQgBCAAAG/0CAcEgsGo/IpHLJbDqf0Kh0Sq1arYeK9hEQKiod0Gg8BnUqiit10CGTOaJx6KzVdkJjEeagfh7iFgNeFQ2CSgMPHGMdaX1KASEiDQVVBRZxGA0YeCMiHA+OABUjDwiGUwEICIqddHAjIHxqIh2qp1MFqhJcRRIiIrJVByMSCMFVA6pdRn8gVwojDQh9AcnTRgESpFbQhY4DyQfLQ3yeWNGhAOCqBcupAXBWFuih4LmqCPcDo8IjHEwVoFQbcA+fKX5U2twCwEBEkRVRwFkzGAChlAEjMAxBoCIDigxFUIB6IrGgsjtU5t1KFLBIBRUSGIx7JNEgggAZqdB68kCEif9rTCQewLdvRKMow0amG1JS1YE/HaiMWpiu6TQQwKjEYwC0as1pIf4lrLVixceZShBUyGDCBMgjEq0FCFOlgQACAB6AWKGiJRIGIFSURWFChAQkcW3NoyIAAIUNbE2gGHwEgYmyK0AwMHRXQGMiiQ+OoEJgwQUNhDlkWO2XiATCkzGjaCzAtAPQXwtYlCLCQhUEDyQQMAABwoUIuNfl2x1lhO8rBDZsuHDhM4CBBNktHlsk0BQBBopg10dXawiXIBr0iTvUVNgqU12S6UAfVeh8I1pHgaZUiIQSKaRwQgojUBWUVcAZZYU5RFQAYIAplHCYQPcVEI8VGBTYjhAVDAj/4QlRPYHdAO2pktM5FhgjiIMQBjiaEyOaNMoxCYnAFTj/tUiggdjEVVADbRCjBjS1HEDQCDoquERc2anSEwhg5KdGhsUYiQEJH76YxIhNqhJCCFwhgBVaUgTwizSmZEgCCc4hEQCXXSIwjziqNLDNFcNoxg4CDTSw2QBvBsokeza9p44qIGj0DB56sjPoowgaRE8qCGAQohUVTDBKLAYVAGlJJRp0gBjuqGKBM1dUUMwoktiUTwGwxhqqTQ3EoaU12qhRQYoIKIBJAbO6KqwlnSgyxD2WDvmBLfB0UoFywnaqWxwcBGDnRqokewVGaHoR5CeA2hOrRJqU0cgfQkwExWUfHXDAzhCslMFBHVpwIEaxxZgCGj520kgFNPkaYucDDVQAAidkiJDoBMIGa0Yol4TZRYbjkCiqpyZFu8oI/mIIpjJzHPGmEQURbFADH9yZjgUhlMKAlCSpknIIH9g7QgjqLeUFzYrkHDMCEswDpc86k5PhUT+LeV7RRzygZBTIcsy0EaMgDYUqEwg5NRFOW/2zP1sTAY3XTyC6dNgA8IfMxminCzMVlT4dNtjIZE120ShZoc3dOqtkhdMTti344IQXfkUQACH5BAUKACwALAIABAAxADsAAAb/QIBwSCwaj8ikstjgjJ6gh/DQqFivjcFyWww4RZiKJTQKiZ7o9Ajc4G5BIwyC+LBKFF2FxFmuBNxHFSMTCFqAQgEPZCJSh0MiHQiFjkMIEmQdAQp1CoZKDSMPCAWUQwOjfGodeEmCBaSlQwUIFnENB5oWZxatI56xAAGnsEReIxJIFSLARQPOSHC/QgOQzM3P1yO8RR0jB9bFA69/lQEgIEUPIxVJwpTOswUDAbMDtUUhIeQAD78ZGe+cSRpYSBCdUAAkSBigYs6QDOgcCRNHsOAIIiBCCEGAYgWHZioYSHR2imCAe1PWbZGgYsUyQCQlHTgwB0SHIYKkgTMFb2CB/wPHhnTQuPMIyZIIAnTzFKeo0ZiFJKicNmKFCQn7uCBgUAFgkqOS7F0cQqCBrhUq2CkZUMHEirdo10ItIIicgAAONlQA8RaFwyIM3FqtwMCuAAIGBBzmKXCUghGsEF/Q8NaE5UZF4MJFYYLBXQELIFCgsIFxyQKPWQGI4OGvkq0MYnc1QQBA6AsXHCQ1LQk15CGpgQkwQOHCBgNGwI4Cpfpxm2CYARFwoNvIxMZ0xyKaSk01uOuzRmF4OSTERyENRITocEUnTKiFbBbhQB5AhxP4S5DYRuk6UgRTDaHOcwCMkMKBBxIVUGOSqPNNMU1pYSCCKXizIEW9ZXQEBr6MMv8hgiUgc8hR/4GiVhGPVXBAASBQmEIJ/HFB4kATZOQLEt0wcAAGJVB4wk1c+IeUExg4cWIRQIGAACgU7ifjjJJwSAgCTrgHgCAVICBICVyOIFI7JDLIgAgWlMRAUNAMsiQGFliQxTz7BCBnmBhKUssfAUjSAZBHBCCCCA34ROegDCJAEwgYVILAeEoc8KcEBMlDaE8VScKIouosIcg6P0X6CjyvVOoTh6zkicAECuKoyAgdhCrqqwM1AMdvwdjJJxIhSLIpBq7C6tOia0jFSnggxHiEknMM0M0IHDQwUa+fFvDAshj88ZupCITg3bFhTbEsqxbcocC4YswKxiQAzIGYbQOp4jilUIBiMKsaI4DAwZQ+hTcQBtEhIQGyWgSgjSkNKKRQoJ36uuQHMqpZCHPWyVmEvpUyAIKVRijDgJ3aBSkJA5A2CMKDbmS0sYaHmEpfRtVKZLJ8EknSwFKxjLFeKSVNgFAsB9xcysfMMrNnLKaaIfStjsxSJTBDMaMlraVwyEwBUolYiiAk93fmkY481q8jQHENQBAAIfkEBQoALAAsAwAFADAAOgAABv9AgHBILBqPyKRyyWw6hQEJaETlKAAKSaXD5VYk1+cSERqFLBWMiMoGdadUEechPiJEIslgGHgoFHtGBw9qZhUBdUMdIg0IiUIPZSENB39PDSMWCI6PAwhwbCMgdEsYIwgHj0MMIyIYfg0WZRyISVyBqgABDEcVokodtLl8SBIjFUgDecNEtc0Bi0ggIs7MAQXVAwUPI2FEvhLMRZ4FgQjlx+MjHUm8ideb8Y7pRKaBA+FEK6ra8vPIQwaMwPBJGYciK6o9GeAJ1QFs9IRYGDEggIgV1IqAAKGwSYB+mwpgakBEBDslAUCsWMHJyceGCAKYcqZgBClxRxgWOCdwRCr/Ib5w4RzHEMEAOPkAdAjRkcnHJgwZHpgjZ0iZFSpACLXDAcVKE1CjboJ2EgCDbSpV3CzCwARWEBIYtFQSteGAiUIEENhgQYTXFUmFIHC7AoS7IQISL1hgwEECInU3DfAlhICDDSZMZNis8OLKzypMFBAAwMACChcubLgAWew5ygAEeAAIlYGEDCYSCFgAQTUCAwojvx4xJGKdAAkuUKCwYS6UqDuHF8cw5KAYAapVRzDyEuQADiEUlQWB4ecTAQkcGDAi3KibIXihdKASosOoXN1hFojIjaSQDyekkMIJJ4THD3TxjMTHQEOAIOCDPj2SXzwHzEQEByIAUNEIDwpY/0JgLtUV3TlVEcHNAwcc4GCHJ1j3xIQSPLCJL95YFcJOHQT44AlleVSXKVXcYWAR3GgyQQks9rhEXd8xgoAEIkzhnxGLyBgCkh66iBKTxpyziTFKEnFAlAwwUAYJrUyJRH46uSJEQyGsZQQ3HGzywAONRBXAnrrsySR0QQ2xCQZaHmFKnagY9eeiCCLAAQhEbCILE6YQJE85jDa6yRlE7GRME6aA4E9IBZRq6ojyjBDYl8Q1MZEIE8A06qzxdBPpk60ywQF4ZjwAEq3y4GMrFF+GiUQHjUggiQUHvHRqqUX1RcVhDVlAXRMcyLUHN3F0UEEFfyjw7SJUgACOoJt8IJBnElpsAgA3X/AaCn0cVNAIGXrosgkmTeUUwiYVZjhEAbZJENc5qH4wgSPxfHCtEx1YWuIzCsFTQQhyDSrCVksccAwmtNVm0gMTTGPeE3QOu9AEZVBhgSrc1ugETCEMmYgvJz8RnSk5PwHbI5tMoKoqNPKDACuFoqxyIpuAYLMYNckshicc5FpHTSEzbUqNQQAAIfkEBQoALAAsBQAHAC4AOAAABv9AgHBILBqPyKRyqOCMniLMQKFoVBrUpfaIeYIqltBzTB6FMI2ttgt6EA9ULFVS4YigloH6+BiBEHpqB2FPGBUVDwF7AGIIi0IKYmUjGIpaByMWj5BRDYoHD2IhB0sBIBibQ5ZFFn6rRqYgqWsjFUimIwqzqkYDAyIhSF2au0MFgUIHA12kRQ1+xUQBCAjHBYASuUUBIiLI0QDT1NQFCtpEXbYAjkMSIrMD44DP6kIDZhIADCpEFbKz8gZUGCFi1cAHKFCoyDcEgQp2m+JRwzWCIaN3ARhAHFJhhQkOm8QBGtHBTDJKSwZoTHUtQMkGzAAMTAMOSYECfT7grAigZM3/JL4EagwwAmS3j9+OBJAAwoSJjUqCSgwQIpgFfyoeImEgYsUKFCAyJAUalNqAkgIEUHDn1Q2RASa+VhibVgBZX2a7CDCwIaGIDBsRePWqwsRfBgECCFAsgEDdxwCkkhto4MKFAkkqMHiQIQMHEyq8ekoAAYKD0w5ML1iwIULZagMx1duDoAICAgYMECgNgcKFDZYjJHhdoAuAopF1pWq8oPRvVUGvAfIpQtaBEGPVEKBAofcGA/aim63ac4QQdyA4HKrwakkE4BRah8dLDvlMISNSnDhRgoTFLQQ44FsEkYmHACi1AGCOJkSl4KB+/6QSgGTjxARANwA0QMKDDo6Q/90WUkl3IDBDtPKAhhymQIJbj0glETXZ1HNPCAXkx2EJs20xIYXkiPFKOh+cwOEJOZbiSyhmTDBOKzn+IsJAHJJQ5F3ZWCBBFw8g0EA37QGQDQitlNDfCFApJdUzEhxATRgMgDACTUY4wQFMGFgAiC+JbbOjVCGABIB0IbiJyi1ucjDOMS4m6mIfEFHjBAhdSnOHoYcqmug1HES4DgIYhBDpNm5+IA85iEZ30zghEJMMAhOYp2NJIjwg4qi0UsNTQwhks8hAJDHwYq3ynCMEjK5ucUBJY4AggTWzkjNAH8qFA2MHewQqAQMwJWsIFdxW0OkTDAwhkQWDbvEmO89wYI3HJGOI8MGtmyLAwX9LkMlOF5bg5C0GhkjQgJoiSKCIOAx4uEcHDRzICLXb4EnEB8v+6SjDajRBTcFTHiGBqOPw+qkwdmYDZ0qUNPCAE13QWwoIH7QSrRbuPBGCBAgE+kgATozQzB4KFKCmvAY/0sos4rTK4h6xwYNAweXukc3Lj1BD3iPmQL1IPE4UEQQAIfkEBQoALAAsBQAIADAANwAABv9AgHBILBqPyKQSOcCERqMQZrCsWocPKKdS4YxEnXDYUlFcz4AsiBEYDhSNbhiqfaCVgxEIQV0OHhgiXxVtd0UYIwV3AyB0ehZ9aAEjdmh5ehhcHVAWaAciFYYAEgdFA14YVw0iHKJKiBJVB1+RrkYBISJLnyKltgC1AAEFWWZIASC9v0IBfEMFCJOhSBYjsctCAwjb3AAjnUd5HeGVd9DcCN4jwUKbfRlEFSCu6OlQqaYjGCYIGSZED1C40ratwCxBwRANyKACRbohAVRkYGeF2wAJlL4VYaUEgQgVuhZtwxUCWQgiCihhSxIN0YSLI3wBqDCi0EojA5Bx2JbnGoD/DiEoJgnA4MyAAQUIAuAo5MkKiUoCVDCxompRK0ePjgzDjAEBBiBWzLsFQsUKERkYXB0iIElWggOqCRFAYMOHqiumDWG4woQEdnQDtA2XlSfNuQk2mEjLhggCvJBRgJBAoG0CA5gzY04AjACfgocBEPCgdwkCBvJQrDAgYAEEBxBiy6awQfSCDQQLhPZW+kyAygLoGpAN4cKFBL8hbDine8QQfQAO9EZD1zUE2px/Gz936mS7cQNCVBBaxcAGCrGNA8t6gCeIcUIQZRMUBahMKxEubDC+gU9hniPolUUDQoyQwoEnlICPJAg44EBSR52DQAMjEMgMdLMcqKF3ogTw/xY3ByBiEwAc6NIACRoeGFOHb0lYAFNYUMIAiimW4JNvLaJDkzFEhBDCiymmUMJ0S3j4IToicAjQNxycUCORSTDQwJHc0GShER2IIIEITqp4Ix6NfPFXPRTCd8QnIEzwBAlRFDDiER5mOQECE4BSTy7kpTHCThJI8MBbOQXQhqBGDkDhA+0hkMUD2xzwgUpLILKTRYBWehRXAJyDwQcIhBjgFYhgUA+Elh6l5RDbMDACA48uaAUiIDRQDwIF1GprrarySFAyGt2RBSgEzYoORjw2g0Ag5dxxQCMh/CnhrMQ6diyUZzzwhAgWHGDkrQVQyCMA22AAzjJZQAEGFw3AwY4FpEJsk0yeV2RRASBPOELHuMY+YWaHCmRJBDR9SrANByUxs40eI3x7hgT17nmLoEIcms3BDMC48J4MyFuFCBgocg4DCDwKrxEgWJBOSgofUYEIIOsoyLhXTMZHMVWQJOs2E3zj4x1dbFPNyNEJAgIIT+yEyH01f8CofFcE8AAXEpyT85dJW3D0QKc5TEQQACH5BAUKACwALAcACQAvADYAAAb/QIBwSCwaj8ikcslsOomBSmhEBT0U2MFzOzyIRiJMhfOlmkMciZar9I4sa0BA0ajYO9Pqg30MTCUBTAEPHFQiEnxDDV97ToMgZxYHbBhgk08WVR0dZRaBTQGQIJdbD59CCqKnSaEjGKuJQ5UWS60YsUh+I3FHlbe4RwUPb0kSIyDAQgFxAwgBVKREAyIivLgI2NkAX8hGlYhQHInN2QgAHVTgQwMjIXIqawwmseXmx9SrlSb788or1k8ClGPHocKIRnJEhIgCiAgHFRkq8CmAbcAwCwWOKSKGhEGGDHzIAZjCYEChNZWiJSOCYIAvBMJGgAshYiUrDiCyERTSLgMs/yMIKkTkMmBAAXIBRCBT0G4FCnNGBoBQscJpzS1Fi1ZEB0BYUKerpK5QwYGBEQECfhbJSs7kCABoNVRdARWAhLkoPpaUg9YA3LRJCGTFVsAg3AQaAErgt68qCgNpDTiA4GCB5cuYLRswQOFChMJvC3hQt6RAAwIEFlS2DKG169adL8i+sGHDBQSZADCtoHIJWjmoE7xubTsBggTIKbbk+oxDhwaJAhCIcOG1bABslQ8I4W5bCAUiCmJR0FtJAtuuKWyIwDZbxg5CTj4gUaIECRLdnziofYFC5w1ZKYfAMBLZdVAFJaSgYAojlLeEZKtRMFg2KQnBDggVnLBgCiUUyP8HARAAaJR7CjnkSoILlvDLhxSwRw42xnio2zEjbHgCfCG1594U1qADAgkp0sLFMjpmY9CKQzCFxgj1jQCdEwccxdaL2DCAzxGZcNCABRa0NIBaUEAyQgdSUonAAZCQFuYIFRA2JSwBLANCCBNI8AEIBQiYTSHiJOFGm25OOaUFIpTjXD0IFAICmF18MUE5ZQoqQoFVhiCBoe0wSoQbGOgJU6QN7KIMNhZwkM0Hx2haBJrHNIBoObkNgc0iA37RgapGBJCJKzC9ikE3QigXAjpsxpIKFRw8cJSAGOBoITaQfOHgEw8QO2YFVyiAwVXPIhBCmwrhusQwzZphrjTYyDRzYLG4kDEEAxJgIG+D66z7ADboAOSEBJz0OQSRdNY7wQjZhIrkE6LIhAQGHxQQbFCXniqCuESEysDACiARagOBvIqAMQjtS3Al+goRwgceR6wUUSO/VcwIj5YzAQgYYHMSFxbMu0QlIYDgMxiAYGNQyAAEAQAh+QQFCgAsACwIAAsALwA0AAAG/0CAcEgsGo/IpHLJbDqPj85o2nk8r8cAaBSyVCyhEahSaQywT+2och4qJBjRNIRRoJWPkMiafEu5fHduYRwBTgESYSF2dwEWIyIShw8cH1NTFoZXA1uFTgdyIh0WHWFibU2gI4FOGA1FClsiB6kis4JGardKAXq0uEYDciGaSFKsaKhCAQMVVEkSa8AAAwioBQUKXCOSuSIgRMpXBQgI5OUAayAixUMYIwoPbSYMggfl+OkW2hhFA2IIVCAQQk9QAHzm0mEYIEVZBREqVnAYkgFFu034so2YoLECkRDgigQQscJENyz4BjxqMBBEiCEHuCEJwOCik3MjQZAbEO1Xz/9pWRAEeNeA3IGY3TiIEJel3hVmIjgMqDZQRD8AHVSoOEkkQAUTK8I6ZRJAgIAEGiJEwNmhg5ARGFAIDAcirIgKDMaWzUUgwQIHDiBQuLBhQ4JyKke87YBihQiKYQsSOSsAAAEBBgxgXgBB8IXPFyIkmIrY2duSGZwiCMt6BQoOly0DXmDAb+fOnxNUpjaVagHT6TwiGcCgAggQBABwXpDAAAEDgm9/Fg1AAAEKpM0Bl9aEwHPrBgYGSEBhwwUK6M1bLm+t3G/FAEJMxEIAwoYiBgA7GFhd7YBzA3DwElbc2KSEABtEwERvVFkDglsAPCLHgxbUARQAzPSW0QgWCNH/wBQnpHDCCSXMNw2D5yDwwAivYAhiCjCm8Ng0GWaHwAHvFMPBCCXEmMIIvxiEYkZREfHhCD6SwEgjQ+ITTYtDhEFCjEoKySBCCIQwIBErylFCCSPwhwWDNpbjDDJCSAGHBWYwxQuZDZbzIYRGgAICA+YwaJMjHVQQQI29pYjPOm4KsSIHKZH5JzXruKQTmYLe+A6aRbyDqHtwMhQCSwhgAEKgWEoKVxOW4lnOAQX0xgCLDX5gQaT4vHMVqQBhiSoGW8opgqlYbjGrE9GIMEGcCIDQoRBUfVABQgVMIAdXTxywRQjynBOCcBiWY8GlPIWxiyAPDGPBAQFwJ0Q5EnyAXwAYkOwI7R0rTiEHtgDcE80cyxa71DQfViCBUvSSU0EXnMo5gomC5CgEBr+SYwEIoa4LDzAh0ClBSEKQA0I/AUR6MC7lYhvTNcWeFOc7hTKhDZQA3DWEwEFSg0+/RgQBACH5BAUKACwALAkADAAvADMAAAb/QIBwSCwKA5XQaAlqGJ/Q6DPQEI1EmEqHiXkMpGBpgzPqfocDCWg5AkkC4TjgocScoYcH+VqBy58DWyIKfwEWViFOf0QPVh13Uw8YHZQVDAwWSxaLQpkiD2AVVmxsHwwNayB+cRgjIQdhFiESdw1bIQwIZKpxmbxhAatErSAIBcTCTw+uyZwAAWQSCAOtGFIDIiKwi80HAyMdBcZroFBb5dzeQwEIASAiAwjG2c0ADeBDtIXyBfHTrQPEFZBQ5omSEQiEmGCwyJ+8aRVGMPAXQAkkeytCrDhjAp0ccQ8HROwXr8Aya0Q4iACB7oEKCQzqQXnYjsyAmwfahRBBJEAb/yONTCSU4xDAypsBjUVUZG+EBGczjS2zgNRhwU4jtkEtEm+AxQBI5VUMMaSDiKFG0mTI8DQOlREVniHNOYCMnxEoVFyUgGLFChQmMizaFoCAYQIIHFzwcCGCgzYrBAtp0BfFmykCBNQLIMDAggUOIIiGQOHChQ0XHIhQsSKuENZ+VYjQJySzAQIABBhOkMCA5wWjS582HUFUW7wXATB4kKHvChO6nwEX7eAz6NGiKWygkKAASAVwhYSXEkDCA8PTFyQgkFlAAtMUgg+P0ADBbg0XfKIMo/u2HwEODAGgdqZdUNoGGzxQAAELHGgAPlARkMAGuBURgAEF8NbPQ6JEkP8AAFu0xYkA2gkABVg3gXTMCH60YgUIHYQgkzNV5WTMTkMsE0IJKZxAgkdbyRXWQyNwgMYSPPYIQpBE1PjQBCN4tAUJKVTJIpMAVAWSPGsIs8wIVaZAAiFBVuUQAvfsN8RBJ4jJ0FZm2ijPFmQycoUSZyUHTJw0EdQBFGvARJKeAyigFRp80mSFngAccEUu3iC1ypdXoWgmTfKQ4RoUEeHCj5n3cHDKB3aYmRSmZPwJRiueIhDpTSBwIOcsl2KKAEG/rNoGTQcUwEBWz8jTSIq2ZnrFobom8tABGJAlhD8gTFCsPB+0gWwYEY1gAUgcqBosAhZwYOtAjswohQJ4VlCCQKxEyKMGTQMdtEmQSFiRjZriSBDCTQ3IsoRKMmJpyBLeApAvOGyIwEF9U2EJQCbdEiFOJm1wIC1NNmEZAgjgSQwuCN5tSdNVcMLlk1bigKDmmQgAFCR4hIAwb5YtA9noyDM7E9EXsqCBQExZCiPnO0FG9KxTR4hV0aZCcDgCU0UEAQAh+QQFCgAsACwIAAoANAA1AAAG/0CAcEgsAhQVDmjEZIY6lYZxSq0aDxiRE1rpVjohpgijsJqtig6T8xhUAw8Ms1M+2wEBy0hkcd8HFlocfndUB2GDZwN1QggIeiJShUYPe5JUARJLTSEVAQOODWEVk0SVIIRUHCMhFhINFUuRAwcIBUsYpQCnAYqMQwphDbQIA3KkhQcjIL26QwEiIgXEAWoPdwEhIqnOiyMTA6DFINt2cpd/3AcAT5+gB8odZwojHEMV3FUFxUKggCMAwu0bUGHENSsdRIQ4aIJBMkcQCQIMJ25AiBBWDqgIscIPCHvYakUsiEegrUoHp2TJkBKBCg4M8k0R50hiyXCOAIiQR0UESP8iA0CYkHAHIoIAHDAGNPlPJr2UzvpBDDAi19IB+woog3pvhExdNQvWoShOp9Ui1mZKyGBCRDMrWBGM4LmUAIECBAQkYCBA7wUKFyIIXQGVgYkVK1C0fWumQTkAAggYWLDAAYTLlykA3rDhQr0VIhodXiGBMZEAkfsKQI1H9WTLmQFf4PzXgQMDvUQkPqgbcWI2z/oSoDyccoIFx2Fj3kwhQgJ6v4SIQGEaAANNKlaoqEAgAYDumB1QpqyZAubMnDtHEIVAcnMhI5BVQcDBgt0ElxfkfSvAQYTZF/yV2WycafABeLPBJ58ZqPV1RgAE+CdbcxEgUFAAARhwmxAggBD/lR3uxGULSUaoQdSHcFEk0gAdeGhEQVowER2KIdI0gE9T0DPCCSmUsCCKV4noyAgnGqEFjyfQBWSNRunxlRwlpHCCUkuStU9NO1WhzAhSAlQlRVc6IoFBCI1AwgnbVFdIjTTZcpEZOtZDUTdktWkhmWbIgQECB1CkJiZ1hhnKXCBG00BNforCSnQY1ikkROSsYwc9IDDgyDQDMLDMBFmUxqaVEIm0CldmnGLppSFwANEDIRTj6KMiyWGBLqY6MsEIBQRwpQWoWCmoUR9UFVUlkdBHF0QiKFCAVkY1y4AsX02qBQYgyCdOfc02WwCMXcz6IVJMLGjrB9leWkGMjjBAq+WH9IiLgCbLYjpAA1mwoqcjIURbCBRE7CNBJ10o0cQHEzgihwQIgDCjLvwOsY8eTYjw0QSnItuqwkACYIGSD4Ng1DS/vhtfCAuX8kBoDieMAYZGtFnARSOUPMkAI0gKwD4fkPqMUWOO8Ock9Jy1TxtWBGAUoRnr6EdZAHBQZBFGO6LGz4Xo+FNNY8osTkHoRBX0XF5gEIbORAx6FrsxK8BBjCD08SC+LloRBAAh+QQFCgAsACwGAAkANgA2AAAG/0CAcEgsAhQVDmjEZIY6FYVxSq1SDxiRE1rpVjohpggjtZrNig6T8xhUAw8Os1M+24UBy0hkcd8HFlocAXdnB2EcflYDdQEICHoiDYVVD3uTbxJLTSEVAQOPDVoPlEaWIIpUciEWEg0VSyIMoAgFSxilQ6eEZgd1QwpaDQMHB7YjErkHIyC8uUIDIiEFxAcDS5h3ASEiqc8DDSMTA7QD3N5WGCPZf94IAE/ktAgjHXcKIxxCGehVBQh+QAVQ92nAvwEV1tnp0E2ICQaUDjyaiHAEAHmPooUwNKLCEBD6CjmaCDAhgIIHE7Kbok4RAhUcZv0hGcBkQVoBRISsorMIAv8QJpLdIQmgAwho5CQOIFgFH6lnROYFGIHrIrl/BcI9nZKwX66MCcuQI0CgQAEBFh4IMGDAmRAwUwZIyGBCxJ8C+OwFWLtggYO/DvpSuHBhwwYiIOwRYWBixQoUdSk9EFHAL4TLmDEPLkzBAJGOQxA0XiHBLZG9AgQEcLbXwILMmjdr8JAgtYAioIWIcOwYBZshqA1AMCAggQECBhK8hg1hc4QHDApIsIB8wQUHnz0WYaBJxQoVFZADWIv5b9/XFGAXjkDtEd7wCThnt4KAQ4PqlxfUVi3EQITChm1wAXsY1SLBCAUAIN58Z6RGlmlGrIaHPLQUYBIViUFlx03/1KL/RxVwaWgGhRIB1IFiXFFVgVAiFnHTPANQ1dQIJJQwAoQiUtghApZsNYUIJaRAwi8tvkgSU1VgECQJE7QInI4TFdCTFfikUEIfTr64IwIH+khFCCeUgAE5OGpD4TyPhLDRGeGMYIE15HxzJkkIJORlksggACcDHHRAxhkvGkRnOCgCKoIkE0mDAQd8ULHamYLSeQ4l+IDAQH2WhhICBqt1Cqk8JZL0ATK5nMIAMpGK0san8mw5kTpPPGOJFn50WEEIrJpF50RLcPATkXdYYlFoaTZg1rGh7spAGJ4gMEFVpQ4LzSMc+LrrrgXooZAjy0KFzy+PaHItSRZqMcKatEibsQupQ/xz4FXHytNAFufqUVW6wN4BUlRc5uNFF0o08YEEesohBb5QHegMKAeG0cQeIE1wKUnSAPBPOGWeEaN2Jz3STbK1REqSnY9UYJeGWTjzSJNHIAAhmgWoSS2037g5BE7wcOziyMgwIEK+lKhEbAHqAN3xRPlYsJOIDGECxxI6xzURQx9kTKkYDDGzEhW0CO0kAAlh0EUDVhvxiCUWfH3ECEabMZIIhYr4rYb/jHpHEAAh+QQFCgAsACwEAAgANAA3AAAG/0CAcEgsBhqVTmjEZII4lUNxSq1aAQpM81npVixKZsgyuJqviuUI0whYBxIQE1M+2wGDzkhUcVMbYB0dbAUcTBV3Zg0iIxZ+Uw1qgnojIQ8MeiB1iUUVlVJWSg+PAQ+MEwgTe6CcQlogj1UBsUMHIiINCAi3rImeGK1FAwcjHLq7Ir1nDSMgwUUFARwiAwgHtiK0byIh2mYF0UIBCAMPIw0FCAUKIx13esp3B7rz6sQSA+kDnhJn7IgAjLU6pqsAgEYDqiEIECKbmYZ+TDBoNe5YtBEVEqZbhxFNRyEgMgRTqI6dgoQKA3QQcWXaIwQqQiLglI6chREo86kz90DWGv9hGTJMTFQRQAhnAVDqAiCCQxVmDZ5RKTDgZs+kCecJkGBBgIEIFBwkEOLJm1QACCwMGUCgbYIFDiDIpXBhwwUhHZxNecDBhAmWUgMQeCsXAt0LFCIkIDAkhNMhATKoWIFCRAaAFAksKHzYAR8qHwFImIwC85kAAhgTMGAA7tzDDBaGwJCaAAXGBzH3RbGiN586ArySEgAgAIQFCwysjnChuWICERZ2eKCZgl0hoYkwqGCitwXNC6wTFxwgwWJtSdtG2CD9A+oIDnBnnxJAgoTVEDZsIA4g+BWsJKnkzhSNJCJcIjnVFIAIwEwBwoBnXZHTMQHMJ8Q0Ef43oS4MnEP/hQSVDJLhFAkeA+ImRBBTwgkjmPUMgCQVAEIIVoRwQgokKDDiWijVpEuBVVhQAo4T7IjHhrp4MlMVxOBIhot35ESSLiJAWEUHJZBAR0KBSVlPkh5eYcsIEpDzgAVRcQLjMATtYqUVnliAQCYhhKDjaVKySZAcS54hhyEP6HKTBGbNkqePxxhimhkDMCLnMRWIQE6elOrUJoiPJcLOUIlyUKmUiJrYDJRUsPMSAgyIwMCnBXxJUAFahMmJqWvpwsGjbebaphwfVNAgJ8TcKYQuE4Cg67EFeIIRAhK8eQeZKTJLTahtpmMBIx0ckA6IzzxBxLbFSKDjLOQOoEAFcojhpQa4z0T6SDUgMtKEIGqIwcED5iCyLWCtDDBCT+KgOkIBD/jKAQgPWoCBBLEd8wE1umDg7Ds0DhGxEOAMEMuUCDDzKAiLJkIMZjWBFDLGBK3EADMotnITKwWZI+wUPqriq1pnBQBCMgHf9GsVPnIDS4bstAPGHidPcYweLT/DziQVpGlHRTdJfZZJUlXj8YhYS0XlxK2w00/WCOw8YoVJ34GAFokEAQAh+QQFCgAsACwEAAgANwA3AAAG/0CAcEgsGo/IpHLJbDqfyQdnRAU9oNjmoTMSYSqW0CiEeQyyaOEg3JEcilLquHJONweYUeedHDQkIFQYdXZHARZUElAIUyIVhUYHYhyESAcSGB0cFQwIDVwglXYPIiJXSltUIh1iI1YHE118o66zSQqOhAEVpRMHCKUKtCABhQelDQjAIrZPx8SQAAcjHMrLokwBIcxYxUUDeCO/B9MgWIgNaAcFRAUFDSMNBQgDFSOPTtMcQxLYqMoD5hUIMMLCgF8BQIjwd4TLCARCTDDAYs0agILglCkYgUGLChEq6ojI0K0iO4wHEQjg4k0JhlKnADBQkYFBSyYDrBWYRicggv8CGxUtEbGvCAMRJoQ6sTbgwUNwOSGGMKdkY0xIUQGACAEA6rw1I7AJSGAAgD2GaOhJuNcVnMCNDAQQSLBggQMIFC4A4CAC4pEBEjJkwJdNK1WvygQYoAuhcd4LkLWiCGnUxIoVKEyIgBLAG9SABhY4hkzBgcohHFcUlWkZhQR2WQIIABCAAIHQdxtf2JDg5hCQqodYvrzCRIWBAuQuEdB5QWi6C3Zv2ODBg28iILEhYJDBBAoDoRfwRlIbwHMCAj4DtKeE7ZLbCaY7QJI8ubcA6gvY1jD+iPsmBhDAGWK35bWBXkeE0EE0fSBGzwcaOCBgQyMoxSAR6ilDkAVK2CP/hoKhXIgfVBWNcJUR8IRQQgonlEAYViRasxZaQogwwooschXNZ1H9tBUTeZCQwpDiQDJiRtYw8N8tVJwwJAkWxvbZPNbkQeMQDjnpoh1H+lRiR01sFEIrDVyJBI9UWsOFmUNM8QADB0B1XRJdemmNUxw+EYAIIXRyQAMWvDbnEJ3xaKcyDfA5aBLwgMBAHmOKYBA4nVVqaIwVIaBQM06sxYUFyjwQAiWXGppmRYGcCEUeIPyiDAMhTFqqO5lakyokIOBDpVPyuOPrTrXeaaOqWXRAGJUYVBNssAXkwU00xhKBaF/L6lQAL10sikUHYApBZQhlBvRrAeA0kIcrbl4YgwYRASgTCLcVxBsvBoFQwYEE7i7EIDy2KNOBCPXK0QUIHEzQyZ0cXShpOwhYsGCP1rpakZUMvtRSThIsSOh1pyKQ8I4FSYuAUAb1MfEI2j5hjzDeKtPVCCyfKWOFDCYkwn223rxEjwBf+EwdATygUMz/MIKyzzZ2wAo1nCahjD3EHhEEACH5BAUKACwALAUACgA8ADUAAAb/QIBwSCwaj8ikcsl8gEZQToNJrTIPz5ClghGNQJVKY2AtVwMiUYUsDCgkXaj2YK4bHyGRIumuPEcdD3Z1DSEjHAFVAxVeHXSDTAEcIyISZxIcf1AVkEpYIxiJVA1yHRgdXoCinUQHaYJWkntED14gq6yuIo+sAAFPt71ou72tUCC9HSNTgwFsQwMDGFAWnRIjnJ0FCM8HAw8jhrN1AyLI0IPbCOoFCssiIYPTb2wmDIMI+fnty+CwZQMOIVCBQIi9ZvrWubMUIp4ZRipWZBiSQQSuMuq4+fu2zEyIc0QCmFhh4l8ZfZJE5EPDgY8AAgYWCDkwwtKRAQwuVtlWICCH/wPcph0RENMBhKNCrvEq1gZBAGXr1oEbB0BAAqMQKFy4QEEIBxHPkgwoWMaZCAsDthEoUEFCAKILjmbdEMEAkQ4qVNgssmjkihVkTw4gIMAqgQQJFizQunXDBQJGQKEgSGQAiL9qGNwjB9nqAgMPJlQ1QNqATiGAUKwQ0SbD34NDCssWQIUAYQPbBnTgUJjKCJIZNjP4S3wFigICEhl1QGFDYCTRouWTFnOD72w3GYRJHnfrhQgOaPOJro568+u1DVCAQPcM+ekdOiQQv0RESyoXNmi1DgCykuhpTQdCB1Yo4xYTAjC3wQZEXeDAf9GhhI0VFoTzRQdcLIWEAAts8P8gEs5EmA8DI5i0BCkjnJDCCSeUgAEVREEonT4VjBDWEgFAoWIKPLLGSogzrgOCQ1ZMUgKPPNrYCZBjJTRCNWWgiGQKJFBlBpMZITDNjVQYQgKSVTYDYJYIHGIHOF6UUMIIBdgBYJD5TKJhgSJMgIEFY3CpBJMBJgQOlHbQBAID6wB4Wkhv9qkPA/AcWgU4HOiTaACrUJpoNGQi8ISVdaAhBwYM9HTpqIom9ISJdnQQwgQSTABCJQgcICqppZpaYi8BPZBQjRMkVMCvwP6a0LAMGIKqHe6IiEAtug7r7LM1isBML+4MEYA+FnxQ67PTSWBICHoOEtA41+bTUAVOpRWN7K/SWeDFRyNw2okWIeUzjRwcVPCAAvxKUAEqx6CLQKNMAcAILttc09ZXUDQsxwd4+jkhUwFh54u5UAZQwAMSdNzAOpkigIqjdTAS1jYP3GctpbiUqw8pFv8IAkhCjGhFlqgUDIArL0KjTxvHEpHRBLcWzHNl+QiR8xLqkKgyU650cGMA08x5hD7K2BEEACH5BAUKACwALAcACwA6ADQAAAb/QIBwSCwaj8ikcslsOp/LQCU0qoYqiuwBymUeqCJOhSOqmkchjmTQbQsHZQxiGMhW7hyQGfQIuKEdIxVsUQ8cVSIVf0wKVIpOAQ+BVhgKi0cVVQ9QFlUgHR1lIxx+l0IYIyINXQ+EQgp6IKWLqLKmQ6gWl7WztwF6rl2ZtrdDBw0jum0Kqb1uAQVDA3NVll1U1qYICAcH2wBUIcLJRiZu09vbAZOPkCIibCgMQyt/6d8iIO/OSg+pKCFQzFIxr02AewFGZdrkBJiECr0kqOCQgR+TAtsK+LNQYAQIJwNGJWGQIUMwSN+oNBhw6CQSCSMYFiOCYAAqDgg0jpDQpOVM/yMsQXirKZKJPhAuiyCQkKEdyAEF0AXI1wSNChVzgGZAsWIFCnNQBohFNyBQVQwPrgb7tUIFn3Njt9kc0SSEiq4r2qXtiqJkKyECAgsmkMDAkbHoCmRqIiJEQSIPTEiWfHfFBwIEBCygwHnDBgqH4+ZczIRckwAMMAeAsOFCggIWAQRAnLFT1Q5JkRAw4ODCBgFDBBDISmcsxpxmmYQAoQaSg+fAhQQgQOFCEcTHB4AQxyRQIxAVGmjhImCDg+uic47o0CST+BEnSpAgMSL2E+zp/DlNcmBEJRIpBJgCCTLBJdY9qGxRlwgKAChgCRgsgl9GjT3RCSoCpnDCB38ghv/ONjAp00RIIYhwgoAnsNeGh/cUQEVuSKBCBYoqQjEbbfdkEqGN76BCQgkxceHhh9swsE8XMIHQgAUWrDSAfUTciOM9H+zkxiE45eQhPwFIOeE9WP7xiyDpRDXkmVPeM4FHUDIBxygtojnkcfcgcAg82ujRQZ05mYkdnXweIlQxY4bwAKB8JpofFR20+cQBWUzSQQOIKrrNMez4YkFjIGx3RgetQJXoAQUUIMEkZWSzyHYN3MNABXqY0YEFD2Rh6wMWTDLCBxIc0JijSyDTaqKbonHGsZ40mZ9pf/jTTZez0cmABSAg8IAEGGSbrQQPKOpThzvxU2mZYs1C5Db+XRIoioJFHMQnu0YAegiwScDBIBKAwnsEnTDxtMgBemBgUTowEkEnVVAEAQAh+QQFCgAsACwJAA0ALgAyAAAG/0CAcEgsGo/IpLIYqIRG0FBFQT0sr8rDU8SpcDpgaJQjGWDPA9HIUjgevCAx6BE4KzuiBrYphnYkdXZCCiEggVcBaiNgHVAiD4IVI4aCB5BDARJql1cYIyGHgkYHalZLnpSiSAMKIxynk6GqRQcBcbJEkqmzQgGBAwgDkhVIrSK4swgHBwgIBa0jCkdP0rxFBc3Nz1FGkhZGJrwB2c7GI8SYIiJmKAxDK9bj2g8jmsdD9CIo+ocq7rzYgnlqIIlTnAESKoSSoIJDBmRXtH1yNknIAFdJGGTIYEbVgAEWRkwIxmGEGQkjOFlL8lECtgL0JAAo2XEly4/AgmEEgQIFgv8lCCRkQGcHZ85EIABMQqEC2YAMKFasQBEuSQABWLFGuMA154BGAESEMLFCBBMQK1TMsWqAAAAHECBQuLDhAoUICRI0G+AJQFoTJsziUyEVxcYHNXsRSCBgwYK5FyIYqDOAgIMN2iSFJUrkAeDPhNOK+AmAgAHGcjdAKFKZa+YRSr/t0WjiUgACWzdscMDkY4GcBUIq7ZBYlAADyI8EwBmwANhCZGyuYr4XRAgAjQiBqNCginQARrMVWARAUvcRJUqQIDECYlHqzegROzACgwISKfKnIKFyVvhsnpgSggj36ZdCCRisZFRAzog1REieGHhCB9YYlVMzKMkG3icinKD/3wkf8GIhOQU8kZgnT3xIoSjL/ZeNJAkSkYgInpBQQkqiWHhhMwyogwtKIDRggQUNfOSejDqS08wH9SBREgfaWIiLLzoOwGA2T1oVRwXiVeklTko2M0EsSqSxCIlfWnglliOsc8UBcXQQZgG/qbkmOSWBYAoicYTwwJ1hksNMfE90cOQRkizSAKCBKtNAI+fwcgCkHSBmZaAH0CkBk21Gs5ICJflhwQNUlPqABZCO8IEEpICyEn1f9CErFCAQmQ09Gs4SUkcIPIABBhVUAMIHDzRKk6SFdlABYsuJGSl4YdbnER4cYCCBBBgwGYIE2VggmBBXlnQoLTQG+gAHXGTjCekQDKIkUxFBAAAh+QQFCgAsACwKAA4ALwAxAAAG/0CAcEgsGo/IpNI4wIRGoxBmsKxahQ8op1LhjESdcNhSUVzPWVAjMBwoFN0wVPs4KwcjEIK6HDQwIl8cHSIhHRJ8ZxgjBXYACnMdGBwgUBVnASIWjgCAD2xDCh0jGFYHIqWcAaBGiw1Lpx2cfQMhIUqnIomzRwMDWWa9IiIHvEQFBXwBCAgBI5dHlcXGx8zWCAAhHEcVIxLURgXX2GFMI7JMdbPL1wDlRYvTGUQMJsYD7WBFeBgmDBko6AXkNUAcggIHoOyyMOJABRUosA0JoCLDLkz49iwasWlICBBKEIiAqKoggoQYQNwSkvAbuCS+CnIoIKGhkJoXXxKJaRCPS/8vOZUEYHAmZkYAIrYBqLSiolAJJlZIJWrFKLMAHUACIMUAxAqtRQJkULHCRAYGDFiFFcCWLYG3ES7I9SBCyDkRUlfMIzJ2BQpEYd8CMGBAwAIKFzZcQBwB8eIIDO36PZuWSIC8mFGAkFCAQIIICRIrdmCgTUxmBLrZhVYFAYMuKMpWPU3AAIW6W1nbCcCn7RHevsQRgLABtzYADnnZdvCbJ4IEGzyszApggIgKQZdE2ECg12lmCUCg68amFhRDIoItYdv8+8FnQhqMeLU1hf0TJVIRdM5MPn1nqYxg34C4rWMVMwcswgoHIvBGwoD2jaDebkYZdFBSREBSAQICQlj3gksU8sdMNxNmIwICIUCYQgm6WQGce8wUYoR8FXRQAoQntEjLgdZ0Q18Ro0ggwgkDwueiUb6MIx86TBTywBMkRNHMEi+KaE0IuiSRBgISSPAAkquwESaSVp70wQjqJMEQB9eQ6WaF45y0SEdLLMLmNcm8WaY1XuhXBUMgMBAnMoQSGqc1DVRC5xUPBILdoZDi2Y0IadoxwCghfGlhpMwMIMETWRrz5BcWHABcocgkaUEg2njzUhZQgMFFAwo0wAUhUICwYQEghGoMjQ+kNMew2lTQwDVLgqPgEOJ0KQEzyBzAjCcIkEiNIeE00AADCiiTjEoxMklEEAAh+QQFCgAsACwLAA0AMgAyAAAG/0CAcEgEKDij5AhzUCgalYazSK1arZYkyGIBKb/KEOYRuJqvmBFIUhY2FQ8nvMIJJUWYwXkvVKgZenwABxV2SxUVEoGCRF4NjEMKhmAYbYwDIxaQkUsNegMPHSMiB4wBIBibRJZEEqOsV6chsKpVFUt8Xgq1q1QDASEie1kcvEUFiwDIWbtXDWq0vAgIyAXUzxKxIiOlxkUB0+EFfhVXt+WDRAzCtQPh1H6pVQEiIhMACCvqJsbvA64jkg1xVQEFChUZiAxYgYCXu2kBkGSqYqcMg4ZFJKwwwQ4SuGmYgnUccgCXmQAXa1mLOEJClketRjzwdmZAAQYjQjSZSARJNP+aQwYIlZByRIciwUxwwBhLAgcTJmbyESoUoqgiakCgWJGtygAQK1agEJGB6UkBBNISKEBAQoYIFyjEXSIB7AqpQcGiyCCQigADAgAsCGCAgtwLGy5EoOAhbgQHBESoEGsiA4Mik8Oq4GiZFloHCSJsGE3BAbJpBW41EyICRN8hFRg8yJDhaWYQVf4aaEP1YeoRqwGYhPQPbxEBgYX0Rq2aiFEAA2DSFLBgg5AAVK1RS4M0xCCdQAnEVZ4d5NWeI8o0aM0BUYXXewwEpRoO01Eit2CKSHHiRAkSmhiDnVDaIfBMgCSZNEIKDPLnnTHLhfMSFcEEEAAJDTLIjUPloRb/jC0yIbBghiV0tUlvD03jijzf5FTAfiSiQ1xvB7xjB3y3WPDBCRmecJ8gA1JVYzgraiNCFhkCeAmKQ4ZTD3xCPLPFCCX8N4J0saAoVJPTfNDSHml00AAGGFjgiVAWfhNkbwWGg8SPJ3mxFGpa1snkO9NkAcJPVJwywpx02skml26OAuU8XoBwUTgHFIAMm47i+Q4SIHTjERIiSNCmpJyG88A2HfC5hwSgAtIppwU0IMoIMkKYRk6a2rQpNe5M4MUoMgGl3Ks5YVCBHE5UgMGtf0qAQDCHQlISBxxsA4YSInwQWzjPFKNrFoEU8ICwHIAQwhYPcJpGcMaAgJtCFjhrOG4IIViwqJNwGsPTdeZO8C4CD3wQQgPvpJHsHn6YCEAFIJxagQjvHkiTH8GBMEGgbXLQQYHenhEEACH5BAUKACwALAoACgA4ADUAAAb/QIBwKAxIQKMkRwFQSCydaLQiORCv2Kz2egiNQpYKRpQsg6TepAjT2LrfgINIJBkMAw2Fwo49SDhJIQ9whEQdIg0IhVcBE14henqLWgojFgiKk0MDCB9lZUuaQxgjCFaiQxNfFnkPY5aoUXyoRW2MgBiiHRwBtES9WaRMiwN0voxYAcUdk0jAx0IDBVcFAxYjz28VIxLQ1AgFvQHgDSPDbwMjzFoMqAEFmPEFledupKcD3UQr7pzx4PTgpMOAAEQxDldWZCPmD9OAgG+uDQgAYoWIhSZALCQ0QFq8Ads2YgkB4k0AEStWZCqkrCEAknAOcPOmpaXDciLgSBgxi+aV/47wCpAx94bDRVEdOQJlAKKcvi1IVqgw+IYpipQmlHbEBACWmxEYHlRUMSjLg6soPkhg0HNLx60IBEjoFkCAgbsJFiwg4ABsBhFXVzwVgsCE1A8rC70lQGCBAAAODDi4QDmCg8uXR0g1wSFDhoUoU4pGIaJCYi2LCSRwoMHDBQqOs4yoQIyBhAyGV7Rl9BYeggFR3sz21c5NS48ICFRYtyUEQiHPfQJ467HxhuhaOpQUAoLDKZrU423wQNvNNWABOgTSXrYf0HgMRtjaUm5+hxMpUpw4sR0V9QPxSGQSWEN0kN+BPLkHFzgwwWGUMgGEcGB+JQzGUnjxOEWIU6aAMP9hCiXkMslxyGFCym5ahBACJvdNeMIHI1LnWzwEFvKAJQhUUIKLzAkk4z8IqIfiFuo9gEAIO1KI3RYklojJTuURIwIIDDDgBQkjiFAck9S9908DIoQg0hs3doDJAw80UE1HAaDXZpdvAQgkCCKctggpHMgD554/AlnQCO2hQgpB8RywJp9e/gMgEoHSQgoIfhpawKSUFsAABl5MaQEDCIAJqE87iTBBQ35iYiUIE0hQgVEiACJCPdAo8MEjDzj5DweQAlmBF0PSMkCeu65ygDKVFgACQZMCieuYtORawE5qdFBBBXo0AMYspH4gok8WEKrKXByk8UkIfWBSDqzHFGNg5Ac5DVFAA3NJcKOFAPimrXQAVCDCA60m02a+n15hYo80vULvFaRYkM04Y+ArhDBw8CtIb1YGLN1O6GYxACmWSOAIGUt6s82IrmgHgljtSjeyO5hck7EvIdECz41REhIEACH5BAUKACwALAgACAA6ADcAAAb/QIBwOJSARkiOAqCQVDpQaEWyJFqv2Oz1cAxZKhgRcgyKHpEizkPLbg8HIlFlMAw8FAr6dfAIj+QBboJWHSMMB4NXD0ciDwd4iWwKIxUICJFEAQiFY0gga5hEFiMHiKFDDH8Ydw0WISMdgadQBaeZDFgVIyC2ULZWslcSlKEBcr/AVwEBHSKhR3rIQgEFwQADBQ8jVYO6FdJWAwgFeuMDxINwHVqXxQWW8JfoghikQgMSViu22PHy34LOYUAgAg4vIiuiRRogDl61eW10HQgAYoUJawBAmFA4KEA/SwUajGgwKMRBLRRXrGjXkSG8APUwZjkwIh+4LAzfIThnz80w/44337gccMZmGw4iZLrxGJChODVpBBVaoQIEUCsIOKBQaaKpSwTM1rkZsaqiClBXGJigCkICA5ZsnDYcMEoQ2Qwitq4A+GbtChC4Fjq1NECXXaomPmTIgJGDyseIMwSOO3ic4bF83Qxg8CCDCRUrJuOsXOByG4iYRGPxmBOkaTYhOAyRHXSaU50DOISQehIEB1M35R4gXEbQKFkBOCAJ0QFEZkysv45DnUUkSSEdTqRIceLEbn634VkXFIDskOzbt/eELjdezEFIPTJLv73Ec/JydY6LOkhkpQMf0MedWIlE95ElulxXkgiWcKBdeid8EImBDcEjwneJ+IdABSTQd//CSZrJVSGCI4VSSAMIhFBCeiUQyEYAEryShj8IiORiIgYxwMARJCCBVhYeaWMBAw3UUwk8IBRkizYdWPLAAyg6tUwgU8rlWzwPyNHgCD+GMgoH8Bwg4phycbnMcAgM08cIFoCDRJNhkkNmmdyUgoAFYmBwU2y7oBjPAQUEKmiglmxDBDyxBfXBhnHMQeOjKRp1jSUW6HkTBhIgsMgIITxwIKS6ZWKJBDf+ogAIlhzwgIwWgJXToOQgwOWhaY5QmxepAqANGh1UUAEeCvjazB/RvDMBhuBMcqSmlPTxSifLcVCBSWAB8A4HtAWlzZHKBVMAAxKEq8A472TZark11SZWRAMifNAAc8pMmcm7HGCgHCzq3uPHfXFhYNIE9VwFzngLicdmvkJMwg2OiCJb2zALJ6JTPcDVpkvEiVgyQbr5XsxPodnWpvAvloDg8E2TKBjKU7ZiEgQAIfkEBQoALAAsBQAGADAAOQAABv9AgHA4PFSOj4BQUemARlAoqFNREK/Y7HDQiUY5ImiIejx2QlAR5qBtEw9hy2BZaczdgwcH2rG6swEhIg0Ff24FFmEYDRhoIyIcD20VIw8Id4aACAh7j2RgIyBsWCIdm5iZWAWbEklXEiIio0UjEgizqVkDm0pYcCBXCiMNCLluAbvFWAESlUTCdsZ4uwe9RQCQb8PSfwPJBb0BCAFgRBbb3G3eq5sI7AOUtByGFcbIA+ztl/FCXagADERcWSHNWzJ9AfgNGIFhCAIVGVBkuIJCUi6D+XidEXIOlZ56VyqokMDA2jGD+sYxFFIq1wMRJpQZQtkO3ggrB5yly4SxHZz/DkIo/duppWcxELKElGMgk6gumgBCzOtnasUKiSbdIKiQwYSJiU+9aQQmpIEAAgAegFihAqQWBiBUWEVhQoSEojQHnBMiAACFDV1NoJibBYEJqytAMBh6xWAym0IILLiggS6HDJjdEpFAdzBiFSIqZBXieFMBftgsEEXwoOsKBmG/oR6h2unJdab3Ur0ix/aQe/hOORnCIURIEA18A3B84JTUIUJDRulAPR3wgwVGuBVmcYiEEilSnEgxgnE3owce3CSSjUgF8OFTlLhrr7TpckQwlAcXdHz8E0Dlcl1z7aykjQW3zPFefOGNIKBjGVHSVD8iMOXNA/DFV14m163S/wAHIIARYDAjmHJJdgyS58c0PVUgQgiJoIOFfrZcggEJ/zl4W08NlLJJAwYuEwsxNo5AAgm0aRHAdbhxIkJwCGAgkBY5KWYaAg00sNgAS3bp2JcEMlCLED+up4V6Vpr25ZpfRjhCL+yEQJ8W+oGQUgFsQkigPhiQtdwmIGiGhVSPELlnAYgmWsCeKR3QwVQAsBNoGwHY+RJDi96S0qZ3nuNWO5NqoQAG7pDzSAViacqpaaeFoZ0Q4gA6py8cbLJEFyNEwuU6iRrEiBSjBsiOmCtmEcIp3nkRYhlHgJhGAw+wgUyk7bj4h5y2llVJAxWA4EgUIoCAwQT6JKpPQIJiYX6Bne4IoZ81AzB6AJ4ZcfqBCKM1JgKC7Y4ByGgeptRAF7i0AYslt7x60QhSYYDBBwwX7IaUljSTnDFRgqBxrtwkIkEzxaZykLfpKBDCEyGnwo5+EqeiX8qpbDLBmOmoBzNPm3BcspnpAGrczt1xs8seOy2ULsYv76Rz0TOnHAQAOw==" alt="" />

  查了半天想不出算法哪里错了……然后把10W的数组改成100W……过了aaarticlea/gif;base64,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" alt="" />

  以后这种空间复杂度为线性的题目……在允许的情况下还是尽量开大点好了……

UPD:2015年5月25日 07:50:50

  突然想清楚为什么挂了,因为离散化以后,权值的范围是1~2*n,而不是1~n(因为有查询的n个数)所以只开10W的数组肯定是不行的……sad

 //BestCoder 42 B
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,n) for(int i=0;i<n;++i)
#define F(i,j,n) for(int i=j;i<=n;++i)
#define D(i,j,n) for(int i=j;i>=n;--i)
using namespace std; int getint(){
int v=,sign=; char ch=getchar();
while(ch<''||ch>'') {if (ch=='-') sign=-; ch=getchar();}
while(ch>=''&&ch<='') {v=v*+ch-''; ch=getchar();}
return v*sign;
}
typedef long long LL;
const int N=,INF=~0u>>;
/*******************template********************/
int n,m,h[N],q[N],c[N<<],head[N],v[N],nxt[N],cnt;
void add(int x,int y){
v[++cnt]=y; nxt[cnt]=head[x]; head[x]=cnt;
}
int main(){
#ifndef ONLINE_JUDGE
freopen("B.in","r",stdin);
// freopen("output.txt","w",stdout);
#endif
while(scanf("%d%d",&n,&m)!=EOF){
F(i,,n) c[i]=h[i]=getint();
F(i,,m) c[n+i]=q[i]=getint();
memset(head,,sizeof head); cnt=;
sort(c+,c+n+m+);
int num=unique(c+,c+n+m+)-c-;
D(i,n,){
h[i]=lower_bound(c+,c+num+,h[i])-c;
add(h[i],i);
}
F(i,,m){
q[i]=lower_bound(c+,c+num+,q[i])-c;
if (head[q[i]]==) puts("-1");
else{
printf("%d\n",v[head[q[i]]]);
head[q[i]]=nxt[head[q[i]]];
}
}
}
return ;
}

C

  直接背包DP吧……本来还想:会不会有人直接把ans的初值设为w[1][1]呢?然而w[1][1]>k?是不是可以hack一下……然而看了样例我发现我想多了……这场比赛的hack果然很少……

 //BestCoder 42 C
#include<queue>
#include<set>
#include<vector>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define rep(i,n) for(int i=0;i<n;++i)
#define F(i,j,n) for(int i=j;i<=n;++i)
#define D(i,j,n) for(int i=j;i>=n;--i)
#define pb push_back
using namespace std;
inline int getint(){
int v=,sign=; char ch=getchar();
while(ch<''||ch>''){ if (ch=='-') sign=-; ch=getchar();}
while(ch>=''&&ch<=''){ v=v*+ch-''; ch=getchar();}
return v*sign;
}
const int N=,INF=~0u>>;
typedef long long LL;
/******************tamplate*********************/
int n,m,K,w[N][N];
bool f[N][N][N];
struct node{
int x,y,v;
};
queue<node>Q;
int main(){
#ifndef ONLINE_JUDGE
freopen("C.in","r",stdin);
freopen("C.out","w",stdout);
#endif
while(scanf("%d%d%d",&n,&m,&K)!=EOF){
memset(w,,sizeof w);
memset(f,,sizeof f);
F(i,,n) F(j,,m) w[i][j]=getint();
Q.push((node){,,});
int ans=;
if (w[][]<=K){
ans=w[][];
Q.push((node){,,w[][]});
}
while(!Q.empty()){
int x=Q.front().x,y=Q.front().y,v=Q.front().v; Q.pop();
if (x<n){
if (!f[x+][y][v]){
f[x+][y][v]=;
Q.push((node){x+,y,v});
}
if (v+w[x+][y]<=K && !f[x+][y][v+w[x+][y]]){
f[x+][y][v+w[x+][y]]=;
Q.push((node){x+,y,v+w[x+][y]});
ans=max(ans,v+w[x+][y]);
}
}
if (y<m){
if (!f[x][y+][v]){
f[x][y+][v]=;
Q.push((node){x,y+,v});
}
if (v+w[x][y+]<=K && !f[x][y+][v+w[x][y+]]){
f[x][y+][v+w[x][y+]]=;
Q.push((node){x,y+,v+w[x][y+]});
ans=max(ans,v+w[x][y+]);
}
}
}
printf("%d\n",ans);
}
return ;
}

【BestCoder】【Round#42】的更多相关文章

  1. 【BestCoder】【Round#41】

    枚举+组合数?+DP+数学问题 http://bestcoder.hdu.edu.cn/contests/contest_show.php?cid=582 QAQ许久没打过比赛,来一发BC,结果还是只 ...

  2. LeetCode:接雨水【42】

    LeetCode:接雨水[42] 题目描述 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水. 上面是由数组 [0,1,0,2,1,0,1,3,2,1, ...

  3. 【手抖康复训练1 】Codeforces Global Round 6

    [手抖康复训练1 ]Codeforces Global Round 6 总结:不想复习随意打的一场,比赛开始就是熟悉的N分钟进不去时间,2333,太久没写题的后果就是:A 题手抖过不了样例 B题秒出思 ...

  4. 【codeforces】【比赛题解】#851 CF Round #432 (Div.2)

    cf真的难…… 点我浏览丧题. [A]Arpa和她对墨西哥人浪的研究 Arpa正在对墨西哥人浪进行研究. 有n个人站成一排,从1到n编号,他们从时刻0开始墨西哥人浪. 在时刻1,第一个人站起来.在时刻 ...

  5. 【2000*】【Codeforces Round #518 (Div. 1) [Thanks, Mail.Ru!] B】Multihedgehog

    [链接] 我是链接,点我呀:) [题意] [题解] 找到度数为1的点. 他们显然是叶子节点. 然后每个叶子节点. 往上进行bfs. 累计他们的父亲节点的儿子的个数. 如果都满足要求那么就继续往上走. ...

  6. 【cf补题记录】Codeforces Round #608 (Div. 2)

    比赛传送门 再次改下写博客的格式,以锻炼自己码字能力 A. Suits 题意:有四种材料,第一套西装需要 \(a\).\(d\) 各一件,卖 \(e\) 块:第二套西装需要 \(b\).\(c\).\ ...

  7. 【python之路42】web框架们的具体用法

    Python的WEB框架 (一).Bottle Bottle是一个快速.简洁.轻量级的基于WSIG的微型Web框架,此框架只由一个 .py 文件,除了Python的标准库外,其不依赖任何其他模块. p ...

  8. 【iScroll源码学习04】分离IScroll核心

    前言 最近几天我们前前后后基本将iScroll源码学的七七八八了,文章中未涉及的各位就要自己去看了 1. [iScroll源码学习03]iScroll事件机制与滚动条的实现 2. [iScroll源码 ...

  9. 【iScroll源码学习01】准备阶段 - 叶小钗

    [iScroll源码学习01]准备阶段 - 叶小钗 时间 2013-12-29 18:41:00 博客园-原创精华区 原文  http://www.cnblogs.com/yexiaochai/p/3 ...

随机推荐

  1. Spring的配置文件ApplicationContext.xml配置头文件解析

    Spring的配置文件ApplicationContext.xml配置头文件解析 原创 2016年12月16日 14:22:43 标签: spring配置文件 5446 spring中的applica ...

  2. linux下根目录扩容

    划分出一个磁盘,并将其格式化   [root@gg ~]# mkfs.ext3 /dev/sdb2    创建一个物理卷 [root@gg ~]# pvcreate /dev/sdb2    [roo ...

  3. MacBook Apache服务

    想着如何在Mac OS下部署静态网页(纯粹的html,css,js),用惯了windows下的iis,可惜Mac OS下也许只能通过Tomcat或者Apache之类的作为部署容器.听说Mac OS下自 ...

  4. [python]源码-对象的创建和行为

    (明天论文就要送审了!!!距离毕业一个月!!!) 现在还记得刚开始学python时候被这种动态语言惊到的那种感觉,列表和字典对象可以随意伸缩,简直不能更帅了,但是一直不知道内部到底是怎么实现的,pyt ...

  5. [java] java中的初始化顺序

    先看程序: package init_cls; class A{ {System.out.println("i am in the class A!");} static { Sy ...

  6. python opencv3 grabcut前景检测

    git:https://github.com/linyi0604/Computer-Vision import numpy as np import cv2 import matplotlib.pyp ...

  7. request.get_full_path() 和request.path区别

    1. 都是获取request 请求的url路径 2. request.get_full_path() -- 获取当前url,(包含参数) 请求一个http://127.0.0.1:8000/200/? ...

  8. Python Django 中的STATIC_URL 设置和使用解析

    使用Django静态设置时,遇到很多问题,经过艰苦的Baidu, stack overflow, Django原档阅读,终于把静态图片给搞出来了.特记录下来. 关键的概念:Django中,静态资源的存 ...

  9. 【2005-2006 ACM-ICPC, NEERC, Moscow Subregional Contest】Problem J. Jack-pot

    简单dfs,差分一下A数组和建出字典树能写得更方便,若不这么做代码时就会像我一样难受. #include<cstdio> #include<cstring> #include& ...

  10. AtCoder Grand Contest 019 F-yes or no

    AtCoder Grand Contest 019 F-yes or no 解题思路: 考虑一个贪心策略,假设当前还有 \(x\) 道 \(\text{yes}\) 和 \(y\) 道 \(\text ...