using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static string InputPattern = "InputX";
static List<string> GetInputList()
{
var WillReturn = new List<string>();
if (InputPattern == "Input1") {
WillReturn.Add("8 9");
WillReturn.Add("5 -1 3 -1 2 3 4 5");
WillReturn.Add("2 3 6");
WillReturn.Add("1 5 -1");
WillReturn.Add("2 3 6");
WillReturn.Add("1 7 5");
WillReturn.Add("2 7 8");
WillReturn.Add("2 1 8");
WillReturn.Add("1 3 5");
WillReturn.Add("1 6 -1");
WillReturn.Add("2 1 8");
//No
//Yes
//Yes
//No
//Yes
}
else {
string wkStr;
while ((wkStr = Console.ReadLine()) != null) WillReturn.Add(wkStr);
}
return WillReturn;
}
static long[] GetSplitArr(string pStr)
{
return (pStr == "" ? new string[0] : pStr.Split(' ')).Select(pX => long.Parse(pX)).ToArray();
}
const long TaniGen1 = long.MaxValue / 2;
const long TaniGen2 = long.MinValue / 2;
static void Main()
{
List<string> InputList = GetInputList();
long[] AArr = GetSplitArr(InputList[1]);
long UB = AArr.GetUpperBound(0);
var InsSegMin = new SegmentTreeMin(AArr, TaniGen1);
var InsSegMax = new SegmentTreeMax(AArr, TaniGen2);
for (long I = 0; I <= UB; I++) {
if (AArr[I] == -1) {
InsSegMin[I] = TaniGen1;
InsSegMax[I] = TaniGen2;
}
}
long[] wkArr = { };
Action<string> SplitAct = (pStr) => wkArr = GetSplitArr(pStr);
foreach (string EachStr in InputList.Skip(2)) {
SplitAct(EachStr);
long Type = wkArr[0];
if (Type == 1) {
long Ind = wkArr[1] - 1;
long Val = wkArr[2];
if (Val == -1) {
InsSegMin[Ind] = TaniGen1;
InsSegMax[Ind] = TaniGen2;
}
else {
InsSegMin[Ind] = Val;
InsSegMax[Ind] = Val;
}
}
if (Type == 2) {
long RangeSta = wkArr[1] - 1;
long RangeEnd = wkArr[2] - 1;
long RangeMin = InsSegMin.Internal_Query(RangeSta, RangeEnd);
long RangeMax = InsSegMax.Internal_Query(RangeSta, RangeEnd);
if (RangeMin == TaniGen1 && RangeMax == TaniGen2) {
Console.WriteLine("Yes");
continue;
}
if (RangeMin == RangeMax) {
Console.WriteLine("Yes");
continue;
}
Console.WriteLine("No");
}
}
}
}
#region SegmentTreeMin
// SegmentTreeクラス (RMinQ and 1点更新)
internal class SegmentTreeMin
{
private long[] mTreeNodeArr;
private long UB; // 木のノードの配列のUB
private long mLeafCnt; // 葉ノードの数
private readonly long mExternalArrUB;
private readonly long mTanigen; // 単位元
// 拡張機能1 (最小値と、最小値を持つIndを返す)
// 最小値が複数あったら、左のIndを優先
// 区間指定不可(全区間のみ)
internal void GetMinInfo_Left(out long pMinVal, out long pMinValInd)
{
long CurrInd = 0;
while (true) {
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
break;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMin = mTreeNodeArr[ChildNode1];
long RightMin = mTreeNodeArr[ChildNode2];
if (LeftMin <= RightMin) {
CurrInd = ChildNode1;
}
else {
CurrInd = ChildNode2;
}
}
pMinVal = mTreeNodeArr[CurrInd];
long MinusCnt = UB + 1 - mLeafCnt;
pMinValInd = CurrInd - MinusCnt;
}
// 拡張機能2 (最小値と、最小値を持つIndを返す)
// 最小値が複数あったら、右のIndを優先
// 区間指定不可(全区間のみ)
internal void GetMinInfo_Right(out long pMinVal, out long pMinValInd)
{
long CurrInd = 0;
while (true) {
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
break;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMin = mTreeNodeArr[ChildNode1];
long RightMin = mTreeNodeArr[ChildNode2];
if (LeftMin >= RightMin) {
CurrInd = ChildNode2;
}
else {
CurrInd = ChildNode1;
}
}
pMinVal = mTreeNodeArr[CurrInd];
long MinusCnt = UB + 1 - mLeafCnt;
pMinValInd = CurrInd - MinusCnt;
}
// 拡張機能3 (最小値と、最小値を持つIndを返す)
// 最小値が複数あったら、左側のIndを優先
// 区間指定可
internal void GetMinInfo_Left(long pSearchStaInd, long pSearchEndInd,
out long pMinVal, out long pMinValInd)
{
// 区間の最小値を求める
pMinVal = Internal_Query(pSearchStaInd, pSearchEndInd);
var Stk = new Stack<long>();
Stk.Push(0);
long MinusCnt = UB + 1 - mLeafCnt;
while (true) {
long CurrInd = Stk.Pop();
// 対応する区間
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// OverLapしてない場合
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd) {
continue;
}
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
pMinValInd = CurrInd - MinusCnt;
return;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMin = mTreeNodeArr[ChildNode1];
long RightMin = mTreeNodeArr[ChildNode2];
// 枝切りしつつ遷移(左優先なので、左を最後にPush)
if (RightMin <= pMinVal) {
Stk.Push(ChildNode2);
}
if (LeftMin <= pMinVal) {
Stk.Push(ChildNode1);
}
}
}
// 拡張機能4 (最小値と、最小値を持つIndを返す)
// 最小値が複数あったら、右側のIndを優先
// 区間指定可
internal void GetMinInfo_Right(long pSearchStaInd, long pSearchEndInd,
out long pMinVal, out long pMinValInd)
{
// 区間の最小値を求める
pMinVal = Internal_Query(pSearchStaInd, pSearchEndInd);
var Stk = new Stack<long>();
Stk.Push(0);
long MinusCnt = UB + 1 - mLeafCnt;
while (true) {
long CurrInd = Stk.Pop();
// 対応する区間
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// OverLapしてない場合
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd) {
continue;
}
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
pMinValInd = CurrInd - MinusCnt;
return;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMin = mTreeNodeArr[ChildNode1];
long RightMin = mTreeNodeArr[ChildNode2];
// 枝切りしつつ遷移(右優先なので、右を最後にPush)
if (LeftMin <= pMinVal) {
Stk.Push(ChildNode1);
}
if (RightMin <= pMinVal) {
Stk.Push(ChildNode2);
}
}
}
// ノードの添字を引数とし、範囲の開始添字と終了添字を持つ配列
private struct RangeInfoDef
{
internal long StaInd;
internal long EndInd;
}
private RangeInfoDef[] mRangeInfo;
// ノードのIndexの列挙を返す
internal IEnumerable<long> GetNodeIndEnum()
{
for (long I = 0; I <= mExternalArrUB; I++) {
yield return I;
}
}
// 木のノードのUBを返す
internal long GetUB()
{
return mExternalArrUB;
}
// コンストラクタその1
// 引数1 外部IndのUB
// 引数2 単位元
// 引数3 初期値
internal SegmentTreeMin(long pExternalArrUB, long pTanigen, long pInitVal)
{
mExternalArrUB = pExternalArrUB;
mTanigen = pTanigen;
ConstructorTreeInit();
// すべての値をpInitValに
for (long I = 0; I <= UB; I++) {
mTreeNodeArr[I] = pInitVal;
}
}
// コンストラクタその2
// 引数1 初期化用の配列
// 引数2 単位元
internal SegmentTreeMin(long[] pInitArr, long pTanigen)
{
mExternalArrUB = pInitArr.GetUpperBound(0);
mTanigen = pTanigen;
ConstructorTreeInit();
// すべての値を単位元に
for (long I = 0; I <= UB; I++) {
mTreeNodeArr[I] = pTanigen;
}
for (long I = 0; I <= pInitArr.GetUpperBound(0); I++) {
long TreeNode = DeriveTreeNode(I);
mTreeNodeArr[TreeNode] = pInitArr[I];
}
// 木DPの要領で、葉から根に伝播
ExecTreeDP();
}
// コンストラクタその3
// 引数1 初期化用のList
// 引数2 単位元
internal SegmentTreeMin(List<long> pInitList, long pTanigen)
{
mExternalArrUB = pInitList.Count - 1;
mTanigen = pTanigen;
ConstructorTreeInit();
// すべての値を単位元に
for (long I = 0; I <= UB; I++) {
mTreeNodeArr[I] = pTanigen;
}
for (long I = 0; I <= pInitList.Count - 1; I++) {
long TreeNode = DeriveTreeNode(I);
mTreeNodeArr[TreeNode] = pInitList[(int)I];
}
// 木DPの要領で、葉から根に伝播
ExecTreeDP();
}
// コンストラクタのヘルパメソッド(木の初期化)
private void ConstructorTreeInit()
{
// 簡単のため、葉ノード数を2のべき乗に
long ArrLength = 0;
for (long I = 1; I < long.MaxValue; I *= 2) {
ArrLength += I;
mLeafCnt = I;
if (mExternalArrUB + 1 < mLeafCnt) break;
}
UB = ArrLength - 1;
mTreeNodeArr = new long[UB + 1];
// ノードの添字を引数とし、範囲の開始添字と終了添字を持つ配列の作成
mRangeInfo = new RangeInfoDef[UB + 1];
for (long I = 0; I <= UB; I++) {
if (I == 0) {
RangeInfoDef WillSet1;
WillSet1.StaInd = 0;
WillSet1.EndInd = mLeafCnt - 1;
mRangeInfo[I] = WillSet1;
continue;
}
long ParentNode = DeriveParentNode(I);
RangeInfoDef ParentRangeInfo = mRangeInfo[ParentNode];
RangeInfoDef WillSet2;
long Mid = (ParentRangeInfo.StaInd + ParentRangeInfo.EndInd) / 2;
if (I % 2 == 1) { // 奇数ノードの場合
WillSet2.StaInd = ParentRangeInfo.StaInd;
WillSet2.EndInd = Mid;
}
else { // 偶数ノードの場合
WillSet2.StaInd = Mid + 1;
WillSet2.EndInd = ParentRangeInfo.EndInd;
}
mRangeInfo[I] = WillSet2;
}
}
// 木DPの要領で、葉から根に伝播
private void ExecTreeDP()
{
for (long I = UB; 0 < I; I--) {
long SendNode = DeriveParentNode(I);
mTreeNodeArr[SendNode] = Math.Min(mTreeNodeArr[SendNode], mTreeNodeArr[I]);
}
}
// インデクサ
internal long this[long pInd]
{
get
{
long CurrNode = DeriveTreeNode(pInd);
return mTreeNodeArr[CurrNode];
}
set { Update(pInd, value); }
}
// 親ノードの添字を取得
private long DeriveParentNode(long pTarget)
{
return (pTarget - 1) / 2;
}
// 子ノードの添字(小さいほう)を取得
private long DeriveChildNode(long pTarget)
{
return pTarget * 2 + 1;
}
// 葉ノードの配列の添字を木の添字に変換して返す
private long DeriveTreeNode(long pLeafArrInd)
{
long BaseInd = UB - mLeafCnt + 1;
return BaseInd + pLeafArrInd;
}
// 葉ノードの配列のK番目の値をNewValに変更
internal void Update(long pK, long pNewVal)
{
long CurrNode = DeriveTreeNode(pK);
mTreeNodeArr[CurrNode] = pNewVal;
// 登りながら更新
while (CurrNode > 0) {
CurrNode = DeriveParentNode(CurrNode);
long ChildNode1 = DeriveChildNode(CurrNode);
long ChildNode2 = ChildNode1 + 1;
mTreeNodeArr[CurrNode] =
Math.Min(mTreeNodeArr[ChildNode1], mTreeNodeArr[ChildNode2]);
}
}
// 開始添字と終了添字とカレントノードを引数として、最小値を返す
internal long Internal_Query(long pSearchStaInd, long pSearchEndInd)
{
return Private_Query(pSearchStaInd, pSearchEndInd, 0);
}
private long Private_Query(long pSearchStaInd, long pSearchEndInd, long pCurrNode)
{
long CurrNodeStaInd = mRangeInfo[pCurrNode].StaInd;
long CurrNodeEndInd = mRangeInfo[pCurrNode].EndInd;
// OverLapしてなければ、単位元
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd)
return mTanigen;
// 完全に含んでいれば、このノードの値
if (pSearchStaInd <= CurrNodeStaInd && CurrNodeEndInd <= pSearchEndInd)
return mTreeNodeArr[pCurrNode];
// そうでなければ、2つの子の最小値
long ChildNode1 = DeriveChildNode(pCurrNode);
long ChildNode2 = ChildNode1 + 1;
long ChildVal1 = Private_Query(pSearchStaInd, pSearchEndInd, ChildNode1);
long ChildVal2 = Private_Query(pSearchStaInd, pSearchEndInd, ChildNode2);
return Math.Min(ChildVal1, ChildVal2);
}
internal void DebugPrint()
{
for (long I = 0; I <= UB; I++) {
Console.WriteLine("mTreeNodeArr[{0}] = {1}", I, mTreeNodeArr[I]);
}
}
}
#endregion
#region SegmentTreeMax
// SegmentTreeクラス (RMaxQ and 1点更新)
internal class SegmentTreeMax
{
private long[] mTreeNodeArr;
private long UB; // 木のノードの配列のUB
private long mLeafCnt; // 葉ノードの数
private readonly long mExternalArrUB;
private readonly long mTanigen; // 単位元
// 拡張機能1 (最大値と、最大値を持つIndを返す)
// 最大値が複数あったら、左のIndを優先
// 区間指定不可(全区間のみ)
internal void GetMaxInfo_Left(out long pMaxVal, out long pMaxValInd)
{
long CurrInd = 0;
while (true) {
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
break;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMax = mTreeNodeArr[ChildNode1];
long RightMax = mTreeNodeArr[ChildNode2];
if (LeftMax >= RightMax) {
CurrInd = ChildNode1;
}
else {
CurrInd = ChildNode2;
}
}
pMaxVal = mTreeNodeArr[CurrInd];
long MinusCnt = UB + 1 - mLeafCnt;
pMaxValInd = CurrInd - MinusCnt;
}
// 拡張機能2 (最大値と、最大値を持つIndを返す)
// 最大値が複数あったら、右のIndを優先
// 区間指定不可(全区間のみ)
internal void GetMaxInfo_Right(out long pMaxVal, out long pMaxValInd)
{
long CurrInd = 0;
while (true) {
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
break;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMax = mTreeNodeArr[ChildNode1];
long RightMax = mTreeNodeArr[ChildNode2];
if (LeftMax <= RightMax) {
CurrInd = ChildNode2;
}
else {
CurrInd = ChildNode1;
}
}
pMaxVal = mTreeNodeArr[CurrInd];
long MinusCnt = UB + 1 - mLeafCnt;
pMaxValInd = CurrInd - MinusCnt;
}
// 拡張機能3 (最大値と、最大値を持つIndを返す)
// 最大値が複数あったら、左側のIndを優先
// 区間指定可
internal void GetMaxInfo_Left(long pSearchStaInd, long pSearchEndInd,
out long pMaxVal, out long pMaxValInd)
{
// 区間の最大値を求める
pMaxVal = Internal_Query(pSearchStaInd, pSearchEndInd);
var Stk = new Stack<long>();
Stk.Push(0);
long MinusCnt = UB + 1 - mLeafCnt;
while (true) {
long CurrInd = Stk.Pop();
// 対応する区間
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// OverLapしてない場合
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd) {
continue;
}
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
pMaxValInd = CurrInd - MinusCnt;
return;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMax = mTreeNodeArr[ChildNode1];
long RightMax = mTreeNodeArr[ChildNode2];
// 枝切りしつつ遷移(左優先なので、左を最後にPush)
if (RightMax >= pMaxVal) {
Stk.Push(ChildNode2);
}
if (LeftMax >= pMaxVal) {
Stk.Push(ChildNode1);
}
}
}
// 拡張機能4 (最大値と、最大値を持つIndを返す)
// 最大値が複数あったら、右側のIndを優先
// 区間指定可
internal void GetMaxInfo_Right(long pSearchStaInd, long pSearchEndInd,
out long pMaxVal, out long pMaxValInd)
{
// 区間の最大値を求める
pMaxVal = Internal_Query(pSearchStaInd, pSearchEndInd);
var Stk = new Stack<long>();
Stk.Push(0);
long MinusCnt = UB + 1 - mLeafCnt;
while (true) {
long CurrInd = Stk.Pop();
// 対応する区間
long CurrNodeStaInd = mRangeInfo[CurrInd].StaInd;
long CurrNodeEndInd = mRangeInfo[CurrInd].EndInd;
// OverLapしてない場合
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd) {
continue;
}
// 葉ノードなら終了
if (CurrNodeStaInd == CurrNodeEndInd) {
pMaxValInd = CurrInd - MinusCnt;
return;
}
long ChildNode1 = DeriveChildNode(CurrInd);
long ChildNode2 = ChildNode1 + 1;
long LeftMax = mTreeNodeArr[ChildNode1];
long RightMax = mTreeNodeArr[ChildNode2];
// 枝切りしつつ遷移(右優先なので、右を最後にPush)
if (LeftMax >= pMaxVal) {
Stk.Push(ChildNode1);
}
if (RightMax >= pMaxVal) {
Stk.Push(ChildNode2);
}
}
}
// ノードの添字を引数とし、範囲の開始添字と終了添字を持つ配列
private struct RangeInfoDef
{
internal long StaInd;
internal long EndInd;
}
private RangeInfoDef[] mRangeInfo;
// ノードのIndexの列挙を返す
internal IEnumerable<long> GetNodeIndEnum()
{
for (long I = 0; I <= mExternalArrUB; I++) {
yield return I;
}
}
// 木のノードのUBを返す
internal long GetUB()
{
return mExternalArrUB;
}
// コンストラクタその1
// 引数1 外部IndのUB
// 引数2 単位元
// 引数3 初期値
internal SegmentTreeMax(long pExternalArrUB, long pTanigen, long pInitVal)
{
mExternalArrUB = pExternalArrUB;
mTanigen = pTanigen;
ConstructorTreeInit();
// すべての値をpInitValに
for (long I = 0; I <= UB; I++) {
mTreeNodeArr[I] = pInitVal;
}
}
// コンストラクタその2
// 引数1 初期化用の配列
// 引数2 単位元
internal SegmentTreeMax(long[] pInitArr, long pTanigen)
{
mExternalArrUB = pInitArr.GetUpperBound(0);
mTanigen = pTanigen;
ConstructorTreeInit();
// すべての値を単位元に
for (long I = 0; I <= UB; I++) {
mTreeNodeArr[I] = pTanigen;
}
for (long I = 0; I <= pInitArr.GetUpperBound(0); I++) {
long TreeNode = DeriveTreeNode(I);
mTreeNodeArr[TreeNode] = pInitArr[I];
}
// 木DPの要領で、葉から根に伝播
ExecTreeDP();
}
// コンストラクタその3
// 引数1 初期化用のList
// 引数2 単位元
internal SegmentTreeMax(List<long> pInitList, long pTanigen)
{
mExternalArrUB = pInitList.Count - 1;
mTanigen = pTanigen;
ConstructorTreeInit();
// すべての値を単位元に
for (long I = 0; I <= UB; I++) {
mTreeNodeArr[I] = pTanigen;
}
for (long I = 0; I <= pInitList.Count - 1; I++) {
long TreeNode = DeriveTreeNode(I);
mTreeNodeArr[TreeNode] = pInitList[(int)I];
}
// 木DPの要領で、葉から根に伝播
ExecTreeDP();
}
// コンストラクタのヘルパメソッド(木の初期化)
private void ConstructorTreeInit()
{
// 簡単のため、葉ノード数を2のべき乗に
long ArrLength = 0;
for (long I = 1; I < long.MaxValue; I *= 2) {
ArrLength += I;
mLeafCnt = I;
if (mExternalArrUB + 1 < mLeafCnt) break;
}
UB = ArrLength - 1;
mTreeNodeArr = new long[UB + 1];
// ノードの添字を引数とし、範囲の開始添字と終了添字を持つ配列の作成
mRangeInfo = new RangeInfoDef[UB + 1];
for (long I = 0; I <= UB; I++) {
if (I == 0) {
RangeInfoDef WillSet1;
WillSet1.StaInd = 0;
WillSet1.EndInd = mLeafCnt - 1;
mRangeInfo[I] = WillSet1;
continue;
}
long ParentNode = DeriveParentNode(I);
RangeInfoDef ParentRangeInfo = mRangeInfo[ParentNode];
RangeInfoDef WillSet2;
long Mid = (ParentRangeInfo.StaInd + ParentRangeInfo.EndInd) / 2;
if (I % 2 == 1) { // 奇数ノードの場合
WillSet2.StaInd = ParentRangeInfo.StaInd;
WillSet2.EndInd = Mid;
}
else { // 偶数ノードの場合
WillSet2.StaInd = Mid + 1;
WillSet2.EndInd = ParentRangeInfo.EndInd;
}
mRangeInfo[I] = WillSet2;
}
}
// 木DPの要領で、葉から根に伝播
private void ExecTreeDP()
{
for (long I = UB; 0 < I; I--) {
long SendNode = DeriveParentNode(I);
mTreeNodeArr[SendNode] = Math.Max(mTreeNodeArr[SendNode], mTreeNodeArr[I]);
}
}
// インデクサ
internal long this[long pInd]
{
get
{
long CurrNode = DeriveTreeNode(pInd);
return mTreeNodeArr[CurrNode];
}
set { Update(pInd, value); }
}
// 親ノードの添字を取得
private long DeriveParentNode(long pTarget)
{
return (pTarget - 1) / 2;
}
// 子ノードの添字(小さいほう)を取得
private long DeriveChildNode(long pTarget)
{
return pTarget * 2 + 1;
}
// 葉ノードの配列の添字を木の添字に変換して返す
private long DeriveTreeNode(long pLeafArrInd)
{
long BaseInd = UB - mLeafCnt + 1;
return BaseInd + pLeafArrInd;
}
// 葉ノードの配列のK番目の値をNewValに変更
internal void Update(long pK, long pNewVal)
{
long CurrNode = DeriveTreeNode(pK);
mTreeNodeArr[CurrNode] = pNewVal;
// 登りながら更新
while (CurrNode > 0) {
CurrNode = DeriveParentNode(CurrNode);
long ChildNode1 = DeriveChildNode(CurrNode);
long ChildNode2 = ChildNode1 + 1;
mTreeNodeArr[CurrNode] =
Math.Max(mTreeNodeArr[ChildNode1], mTreeNodeArr[ChildNode2]);
}
}
// 開始添字と終了添字とカレントノードを引数として、最大値を返す
internal long Internal_Query(long pSearchStaInd, long pSearchEndInd)
{
return Private_Query(pSearchStaInd, pSearchEndInd, 0);
}
private long Private_Query(long pSearchStaInd, long pSearchEndInd, long pCurrNode)
{
long CurrNodeStaInd = mRangeInfo[pCurrNode].StaInd;
long CurrNodeEndInd = mRangeInfo[pCurrNode].EndInd;
// OverLapしてなければ、単位元
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd)
return mTanigen;
// 完全に含んでいれば、このノードの値
if (pSearchStaInd <= CurrNodeStaInd && CurrNodeEndInd <= pSearchEndInd)
return mTreeNodeArr[pCurrNode];
// そうでなければ、2つの子の最大値
long ChildNode1 = DeriveChildNode(pCurrNode);
long ChildNode2 = ChildNode1 + 1;
long ChildVal1 = Private_Query(pSearchStaInd, pSearchEndInd, ChildNode1);
long ChildVal2 = Private_Query(pSearchStaInd, pSearchEndInd, ChildNode2);
return Math.Max(ChildVal1, ChildVal2);
}
}
#endregion